[mlir][Affine][NFC] Wrap dialect in "affine" namespace

[springerm]

update

[springerm]

rebase

[springerm]

update

[mehdi_amini]

Thanks!

Can you add a description with the motivation, even if only: "This cleanup aligns the affine dialect with all the other dialects." or something like that.

[springerm]

fix flang

[springerm]

fix build

[bondhugula]

Thanks for doing this. This had been long pending. This also cleans up the naming/addressing of free-standing methods that were otherwise in the mlir namespace. Having mlir::affine::... for these is a big naming and readability improvement.

[ubfx]

Will the Operations from the Affine dialect also be renamed? I feel like affine::AffineForOp could be renamed to affine::ForOp now.

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

if (auto op = value.getDefiningOp<mlir::arith::RemUIOp>())
       return affineBinaryOp(mlir::AffineExprKind::Mod, op.getLhs(),
                             op.getRhs());
     if (auto op = value.getDefiningOp<mlir::arith::ConstantOp>())
       if (auto intConstant = op.getValue().dyn_cast<IntegerAttr>())
         return toAffineExpr(intConstant.getInt());
     if (auto blockArg = value.dyn_cast<mlir::BlockArgument>()) {
       affineArgs.push_back(value);
       if (isa<fir::DoLoopOp>(blockArg.getOwner()->getParentOp()) ||
-          isa<mlir::AffineForOp>(blockArg.getOwner()->getParentOp()))
+          isa<mlir::affine::AffineForOp>(blockArg.getOwner()->getParentOp()))
         return {mlir::getAffineDimExpr(dimCount++, value.getContext())};
       return {mlir::getAffineSymbolExpr(symCount++, value.getContext())};
     }
     return {};
   }
 
   void fromCmpIOp(mlir::arith::CmpIOp cmpOp) {
     auto lhsAffine = toAffineExpr(cmpOp.getLhs());
if (auto shape = acoOp.getShape().getDefiningOp<ShapeOp>())
     return populateIndexArgs(acoOp, shape, indexArgs, rewriter);
   if (auto shapeShift = acoOp.getShape().getDefiningOp<ShapeShiftOp>())
     return populateIndexArgs(acoOp, shapeShift, indexArgs, rewriter);
   if (auto slice = acoOp.getShape().getDefiningOp<SliceOp>())
     return populateIndexArgs(acoOp, slice, indexArgs, rewriter);
 }
 
 /// Returns affine.apply and fir.convert from array_coor and gendims
-static std::pair<mlir::AffineApplyOp, fir::ConvertOp>
+static std::pair<affine::AffineApplyOp, fir::ConvertOp>
 createAffineOps(mlir::Value arrayRef, mlir::PatternRewriter &rewriter) {
   auto acoOp = arrayRef.getDefiningOp<ArrayCoorOp>();
   auto affineMap =
       createArrayIndexAffineMap(acoOp.getIndices().size(), acoOp.getContext());
   SmallVector<mlir::Value> indexArgs;
   indexArgs.append(acoOp.getIndices().begin(), acoOp.getIndices().end());
 
   populateIndexArgs(acoOp, indexArgs, rewriter);
 
-  auto affineApply = rewriter.create<mlir::AffineApplyOp>(acoOp.getLoc(),
-                                                          affineMap, indexArgs);
+  auto affineApply = rewriter.create<affine::AffineApplyOp>(
+      acoOp.getLoc(), affineMap, indexArgs);
   auto arrayElementType = coordinateArrayElement(acoOp);
   auto newType =
       mlir::MemRefType::get({mlir::ShapedType::kDynamic}, arrayElementType);
   auto arrayConvert = rewriter.create<fir::ConvertOp>(acoOp.getLoc(), newType,
                                                       acoOp.getMemref());
   return std::make_pair(affineApply, arrayConvert);
 }
 
 static void rewriteLoad(fir::LoadOp loadOp, mlir::PatternRewriter &rewriter) {
   rewriter.setInsertionPoint(loadOp);
   auto affineOps = createAffineOps(loadOp.getMemref(), rewriter);
-  rewriter.replaceOpWithNewOp<mlir::AffineLoadOp>(
+  rewriter.replaceOpWithNewOp<affine::AffineLoadOp>(
       loadOp, affineOps.second.getResult(), affineOps.first.getResult());
 }
 
 static void rewriteStore(fir::StoreOp storeOp,
                          mlir::PatternRewriter &rewriter) {
   rewriter.setInsertionPoint(storeOp);
   auto affineOps = createAffineOps(storeOp.getMemref(), rewriter);
-  rewriter.replaceOpWithNewOp<mlir::AffineStoreOp>(storeOp, storeOp.getValue(),
-                                                   affineOps.second.getResult(),
-                                                   affineOps.first.getResult());
+  rewriter.replaceOpWithNewOp<affine::AffineStoreOp>(
+      storeOp, storeOp.getValue(), affineOps.second.getResult(),
 }
 
 static void rewriteMemoryOps(Block *block, mlir::PatternRewriter &rewriter) {
   for (auto &bodyOp : block->getOperations()) {
     if (isa<fir::LoadOp>(bodyOp))
       rewriteLoad(cast<fir::LoadOp>(bodyOp), rewriter);
     if (isa<fir::StoreOp>(bodyOp))
       rewriteStore(cast<fir::StoreOp>(bodyOp), rewriter);
matchAndRewrite(fir::DoLoopOp loop,
 
     LLVM_DEBUG(llvm::dbgs() << "AffineLoopConversion: loop rewriten to:\n";
                affineFor.dump(););
     rewriter.replaceOp(loop, affineFor.getOperation()->getResults());
     return success();
   }
 
 private:
-  std::pair<mlir::AffineForOp, mlir::Value>
+  std::pair<affine::AffineForOp, mlir::Value>
   createAffineFor(fir::DoLoopOp op, mlir::PatternRewriter &rewriter) const {
     if (auto constantStep = constantIntegerLike(op.getStep()))
       if (*constantStep > 0)
         return positiveConstantStep(op, *constantStep, rewriter);
     return genericBounds(op, rewriter);
   }
 
   // when step for the loop is positive compile time constant
-  std::pair<mlir::AffineForOp, mlir::Value>
+  std::pair<affine::AffineForOp, mlir::Value>
   positiveConstantStep(fir::DoLoopOp op, int64_t step,
                        mlir::PatternRewriter &rewriter) const {
-    auto affineFor = rewriter.create<mlir::AffineForOp>(
+    auto affineFor = rewriter.create<affine::AffineForOp>(
         op.getLoc(), ValueRange(op.getLowerBound()),
         mlir::AffineMap::get(0, 1,
                              mlir::getAffineSymbolExpr(0, op.getContext())),
         ValueRange(op.getUpperBound()),
         mlir::AffineMap::get(0, 1,
                              1 + mlir::getAffineSymbolExpr(0, op.getContext())),
         step);
     return std::make_pair(affineFor, affineFor.getInductionVar());
   }
 
-  std::pair<mlir::AffineForOp, mlir::Value>
+  std::pair<affine::AffineForOp, mlir::Value>
   genericBounds(fir::DoLoopOp op, mlir::PatternRewriter &rewriter) const {
     auto lowerBound = mlir::getAffineSymbolExpr(0, op.getContext());
     auto upperBound = mlir::getAffineSymbolExpr(1, op.getContext());
     auto step = mlir::getAffineSymbolExpr(2, op.getContext());
     mlir::AffineMap upperBoundMap = mlir::AffineMap::get(
         0, 3, (upperBound - lowerBound + step).floorDiv(step));
-    auto genericUpperBound = rewriter.create<mlir::AffineApplyOp>(
+    auto genericUpperBound = rewriter.create<affine::AffineApplyOp>(
         op.getLoc(), upperBoundMap,
         ValueRange({op.getLowerBound(), op.getUpperBound(), op.getStep()}));
     auto actualIndexMap = mlir::AffineMap::get(
         1, 2,
         (lowerBound + mlir::getAffineDimExpr(0, op.getContext())) *
             mlir::getAffineSymbolExpr(1, op.getContext()));
 
-    auto affineFor = rewriter.create<mlir::AffineForOp>(
+    auto affineFor = rewriter.create<affine::AffineForOp>(
         op.getLoc(), ValueRange(),
         AffineMap::getConstantMap(0, op.getContext()),
         genericUpperBound.getResult(),
         mlir::AffineMap::get(0, 1,
                              1 + mlir::getAffineSymbolExpr(0, op.getContext())),
         1);
     rewriter.setInsertionPointToStart(affineFor.getBody());
-    auto actualIndex = rewriter.create<mlir::AffineApplyOp>(
+    auto actualIndex = rewriter.create<affine::AffineApplyOp>(
         op.getLoc(), actualIndexMap,
         ValueRange(
             {affineFor.getInductionVar(), op.getLowerBound(), op.getStep()}));
     return std::make_pair(affineFor, actualIndex.getResult());
   }
 
   AffineFunctionAnalysis &functionAnalysis;
 };
matchAndRewrite(fir::IfOp op,
     auto &ifOps = op.getThenRegion().front().getOperations();
     auto affineCondition = AffineIfCondition(op.getCondition());
     if (!affineCondition.hasIntegerSet()) {
       LLVM_DEBUG(
           llvm::dbgs()
               << "AffineIfConversion: couldn't calculate affine condition\n";);
       return failure();
     }
-    auto affineIf = rewriter.create<mlir::AffineIfOp>(
+    auto affineIf = rewriter.create<affine::AffineIfOp>(
         op.getLoc(), affineCondition.getIntegerSet(),
         affineCondition.getAffineArgs(), !op.getElseRegion().empty());
     rewriter.startRootUpdate(affineIf);
     affineIf.getThenBlock()->getOperations().splice(
         std::prev(affineIf.getThenBlock()->end()), ifOps, ifOps.begin(),
         std::prev(ifOps.end()));
     if (!op.getElseRegion().empty()) {
       auto &otherOps = op.getElseRegion().front().getOperations();

mlir/docs/DialectConversion.md

MyTarget(MLIRContext &ctx) : ConversionTarget(ctx) {
     /// Mark `arith.constant` op is always legal on this target.
     addLegalOp<arith::ConstantOp>();
 
     //--------------------------------------------------------------------------
     // Marking an operation as dynamically legal.
 
     /// Mark all operations within Affine dialect have dynamic legality
     /// constraints.
-    addDynamicallyLegalDialect<AffineDialect>([](Operation *op) { ... });
+    addDynamicallyLegalDialect<affine::AffineDialect>([](Operation *op) { ... });
 
     /// Mark `func.return` as dynamically legal, but provide a specific legality
     /// callback.
     addDynamicallyLegalOp<func::ReturnOp>([](func::ReturnOp op) { ... });
 
     /// Treat unknown operations, i.e. those without a legalization action
     /// directly set, as dynamically legal.
     markUnknownOpDynamicallyLegal([](Operation *op) { ... });

mlir/docs/Tutorials/Toy/Ch-5.md

 void ToyToAffineLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   mlir::ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, arith::ArithDialect,
+  target.addLegalDialect<affine::AffineDialect, arith::ArithDialect,
                          func::FuncDialect, memref::MemRefDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as *legal*. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

static void lowerOpToLoops(Operation *op, ValueRange operands,
   auto alloc = insertAllocAndDealloc(memRefType, loc, rewriter);
 
   // Create a nest of affine loops, with one loop per dimension of the shape.
   // The buildAffineLoopNest function takes a callback that is used to construct
   // the body of the innermost loop given a builder, a location and a range of
   // loop induction variables.
   SmallVector<int64_t, 4> lowerBounds(tensorType.getRank(), /*Value=*/0);
   SmallVector<int64_t, 4> steps(tensorType.getRank(), /*Value=*/1);
-  buildAffineLoopNest(
+  affine::buildAffineLoopNest(
       rewriter, loc, lowerBounds, tensorType.getShape(), steps,
       [&](OpBuilder &nestedBuilder, Location loc, ValueRange ivs) {
         // Call the processing function with the rewriter, the memref operands,
         // and the loop induction variables. This function will return the value
         // to store at the current index.
         Value valueToStore = processIteration(nestedBuilder, operands, ivs);
-        nestedBuilder.create<AffineStoreOp>(loc, valueToStore, alloc, ivs);
+        nestedBuilder.create<affine::AffineStoreOp>(loc, valueToStore, alloc,
+                                                    ivs);
       });
 
   // Replace this operation with the generated alloc.
   rewriter.replaceOp(op, alloc);
 }
 
 namespace {
 //===----------------------------------------------------------------------===//
lowerOpToLoops(op, operands, rewriter,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // BinaryOp. This allows for using the nice named accessors
                      // that are generated by the ODS.
                      typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
 
                      // Generate loads for the element of 'lhs' and 'rhs' at the
                      // inner loop.
-                     auto loadedLhs = builder.create<AffineLoadOp>(
+                     auto loadedLhs = builder.create<affine::AffineLoadOp>(
                          loc, binaryAdaptor.getLhs(), loopIvs);
-                     auto loadedRhs = builder.create<AffineLoadOp>(
+                     auto loadedRhs = builder.create<affine::AffineLoadOp>(
                          loc, binaryAdaptor.getRhs(), loopIvs);
 
                      // Create the binary operation performed on the loaded
                      // values.
                      return builder.create<LoweredBinaryOp>(loc, loadedLhs,
                                                             loadedRhs);
                    });
     return success();
LogicalResult matchAndRewrite(toy::ConstantOp op,
     // functor recursively walks the dimensions of the constant shape,
     // generating a store when the recursion hits the base case.
     SmallVector<Value, 2> indices;
     auto valueIt = constantValue.value_begin<FloatAttr>();
     std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) {
       // The last dimension is the base case of the recursion, at this point
       // we store the element at the given index.
       if (dimension == valueShape.size()) {
-        rewriter.create<AffineStoreOp>(
+        rewriter.create<affine::AffineStoreOp>(
             loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc,
             llvm::ArrayRef(indices));
         return;
       }
 
       // Otherwise, iterate over the current dimension and add the indices to
       // the list.
       for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) {
lowerOpToLoops(op, operands, rewriter,
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
                      toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
                      Value input = transposeAdaptor.getInput();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
-                     return builder.create<AffineLoadOp>(loc, input,
+                     return builder.create<affine::AffineLoadOp>(loc, input,
                                                                  reverseIvs);
                    });
     return success();
   }
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
     : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToAffineLoweringPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
+    registry.insert<affine::AffineDialect, func::FuncDialect,
+                    memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
-                         func::FuncDialect, memref::MemRefDialect>();
+  target.addLegalDialect<affine::AffineDialect, BuiltinDialect,
+                         arith::ArithDialect, func::FuncDialect,
+                         memref::MemRefDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.
   target.addIllegalDialect<toy::ToyDialect>();

mlir/examples/toy/Ch5/toyc.cpp

if (isLoweringToAffine) {
 
     // Add a few cleanups post lowering.
     mlir::OpPassManager &optPM = pm.nest<mlir::func::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     // Add optimizations if enabled.
     if (enableOpt) {
-      optPM.addPass(mlir::createLoopFusionPass());
-      optPM.addPass(mlir::createAffineScalarReplacementPass());
+      optPM.addPass(mlir::affine::createLoopFusionPass());
+      optPM.addPass(mlir::affine::createAffineScalarReplacementPass());
     }
   }
 
   if (mlir::failed(pm.run(*module)))
     return 4;
 
   module->dump();
   return 0;

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

static void lowerOpToLoops(Operation *op, ValueRange operands,
   auto alloc = insertAllocAndDealloc(memRefType, loc, rewriter);
 
   // Create a nest of affine loops, with one loop per dimension of the shape.
   // The buildAffineLoopNest function takes a callback that is used to construct
   // the body of the innermost loop given a builder, a location and a range of
   // loop induction variables.
   SmallVector<int64_t, 4> lowerBounds(tensorType.getRank(), /*Value=*/0);
   SmallVector<int64_t, 4> steps(tensorType.getRank(), /*Value=*/1);
-  buildAffineLoopNest(
+  affine::buildAffineLoopNest(
       rewriter, loc, lowerBounds, tensorType.getShape(), steps,
       [&](OpBuilder &nestedBuilder, Location loc, ValueRange ivs) {
         // Call the processing function with the rewriter, the memref operands,
         // and the loop induction variables. This function will return the value
         // to store at the current index.
         Value valueToStore = processIteration(nestedBuilder, operands, ivs);
-        nestedBuilder.create<AffineStoreOp>(loc, valueToStore, alloc, ivs);
+        nestedBuilder.create<affine::AffineStoreOp>(loc, valueToStore, alloc,
+                                                    ivs);
       });
 
   // Replace this operation with the generated alloc.
   rewriter.replaceOp(op, alloc);
 }
 
 namespace {
 //===----------------------------------------------------------------------===//
lowerOpToLoops(op, operands, rewriter,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // BinaryOp. This allows for using the nice named accessors
                      // that are generated by the ODS.
                      typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
 
                      // Generate loads for the element of 'lhs' and 'rhs' at the
                      // inner loop.
-                     auto loadedLhs = builder.create<AffineLoadOp>(
+                     auto loadedLhs = builder.create<affine::AffineLoadOp>(
                          loc, binaryAdaptor.getLhs(), loopIvs);
-                     auto loadedRhs = builder.create<AffineLoadOp>(
+                     auto loadedRhs = builder.create<affine::AffineLoadOp>(
                          loc, binaryAdaptor.getRhs(), loopIvs);
 
                      // Create the binary operation performed on the loaded
                      // values.
                      return builder.create<LoweredBinaryOp>(loc, loadedLhs,
                                                             loadedRhs);
                    });
     return success();
LogicalResult matchAndRewrite(toy::ConstantOp op,
     // functor recursively walks the dimensions of the constant shape,
     // generating a store when the recursion hits the base case.
     SmallVector<Value, 2> indices;
     auto valueIt = constantValue.value_begin<FloatAttr>();
     std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) {
       // The last dimension is the base case of the recursion, at this point
       // we store the element at the given index.
       if (dimension == valueShape.size()) {
-        rewriter.create<AffineStoreOp>(
+        rewriter.create<affine::AffineStoreOp>(
             loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc,
             llvm::ArrayRef(indices));
         return;
       }
 
       // Otherwise, iterate over the current dimension and add the indices to
       // the list.
       for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) {
lowerOpToLoops(op, operands, rewriter,
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
                      toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
                      Value input = transposeAdaptor.getInput();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
-                     return builder.create<AffineLoadOp>(loc, input,
+                     return builder.create<affine::AffineLoadOp>(loc, input,
                                                                  reverseIvs);
                    });
     return success();
   }
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
     : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToAffineLoweringPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
+    registry.insert<affine::AffineDialect, func::FuncDialect,
+                    memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
-                         func::FuncDialect, memref::MemRefDialect>();
+  target.addLegalDialect<affine::AffineDialect, BuiltinDialect,
+                         arith::ArithDialect, func::FuncDialect,
+                         memref::MemRefDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.
   target.addIllegalDialect<toy::ToyDialect>();

mlir/examples/toy/Ch6/toyc.cpp

if (isLoweringToAffine) {
 
     // Add a few cleanups post lowering.
     mlir::OpPassManager &optPM = pm.nest<mlir::func::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     // Add optimizations if enabled.
     if (enableOpt) {
-      optPM.addPass(mlir::createLoopFusionPass());
-      optPM.addPass(mlir::createAffineScalarReplacementPass());
+      optPM.addPass(mlir::affine::createLoopFusionPass());
+      optPM.addPass(mlir::affine::createAffineScalarReplacementPass());
     }
   }
 
   if (isLoweringToLLVM) {
     // Finish lowering the toy IR to the LLVM dialect.
     pm.addPass(mlir::toy::createLowerToLLVMPass());
     // This is necessary to have line tables emitted and basic
     // debugger working. In the future we will add proper debug information

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

static void lowerOpToLoops(Operation *op, ValueRange operands,
   auto alloc = insertAllocAndDealloc(memRefType, loc, rewriter);
 
   // Create a nest of affine loops, with one loop per dimension of the shape.
   // The buildAffineLoopNest function takes a callback that is used to construct
   // the body of the innermost loop given a builder, a location and a range of
   // loop induction variables.
   SmallVector<int64_t, 4> lowerBounds(tensorType.getRank(), /*Value=*/0);
   SmallVector<int64_t, 4> steps(tensorType.getRank(), /*Value=*/1);
-  buildAffineLoopNest(
+  affine::buildAffineLoopNest(
       rewriter, loc, lowerBounds, tensorType.getShape(), steps,
       [&](OpBuilder &nestedBuilder, Location loc, ValueRange ivs) {
         // Call the processing function with the rewriter, the memref operands,
         // and the loop induction variables. This function will return the value
         // to store at the current index.
         Value valueToStore = processIteration(nestedBuilder, operands, ivs);
-        nestedBuilder.create<AffineStoreOp>(loc, valueToStore, alloc, ivs);
+        nestedBuilder.create<affine::AffineStoreOp>(loc, valueToStore, alloc,
+                                                    ivs);
       });
 
   // Replace this operation with the generated alloc.
   rewriter.replaceOp(op, alloc);
 }
 
 namespace {
 //===----------------------------------------------------------------------===//
lowerOpToLoops(op, operands, rewriter,
                          ValueRange loopIvs) {
                      // Generate an adaptor for the remapped operands of the
                      // BinaryOp. This allows for using the nice named accessors
                      // that are generated by the ODS.
                      typename BinaryOp::Adaptor binaryAdaptor(memRefOperands);
 
                      // Generate loads for the element of 'lhs' and 'rhs' at the
                      // inner loop.
-                     auto loadedLhs = builder.create<AffineLoadOp>(
+                     auto loadedLhs = builder.create<affine::AffineLoadOp>(
                          loc, binaryAdaptor.getLhs(), loopIvs);
-                     auto loadedRhs = builder.create<AffineLoadOp>(
+                     auto loadedRhs = builder.create<affine::AffineLoadOp>(
                          loc, binaryAdaptor.getRhs(), loopIvs);
 
                      // Create the binary operation performed on the loaded
                      // values.
                      return builder.create<LoweredBinaryOp>(loc, loadedLhs,
                                                             loadedRhs);
                    });
     return success();
LogicalResult matchAndRewrite(toy::ConstantOp op,
     // functor recursively walks the dimensions of the constant shape,
     // generating a store when the recursion hits the base case.
     SmallVector<Value, 2> indices;
     auto valueIt = constantValue.value_begin<FloatAttr>();
     std::function<void(uint64_t)> storeElements = [&](uint64_t dimension) {
       // The last dimension is the base case of the recursion, at this point
       // we store the element at the given index.
       if (dimension == valueShape.size()) {
-        rewriter.create<AffineStoreOp>(
+        rewriter.create<affine::AffineStoreOp>(
             loc, rewriter.create<arith::ConstantOp>(loc, *valueIt++), alloc,
             llvm::ArrayRef(indices));
         return;
       }
 
       // Otherwise, iterate over the current dimension and add the indices to
       // the list.
       for (uint64_t i = 0, e = valueShape[dimension]; i != e; ++i) {
lowerOpToLoops(op, operands, rewriter,
                      // TransposeOp. This allows for using the nice named
                      // accessors that are generated by the ODS.
                      toy::TransposeOpAdaptor transposeAdaptor(memRefOperands);
                      Value input = transposeAdaptor.getInput();
 
                      // Transpose the elements by generating a load from the
                      // reverse indices.
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
-                     return builder.create<AffineLoadOp>(loc, input,
+                     return builder.create<affine::AffineLoadOp>(loc, input,
                                                                  reverseIvs);
                    });
     return success();
   }
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
     : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ToyToAffineLoweringPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
+    registry.insert<affine::AffineDialect, func::FuncDialect,
+                    memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arith`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithDialect,
-                         func::FuncDialect, memref::MemRefDialect>();
+  target.addLegalDialect<affine::AffineDialect, BuiltinDialect,
+                         arith::ArithDialect, func::FuncDialect,
+                         memref::MemRefDialect>();
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.
   target.addIllegalDialect<toy::ToyDialect>();

mlir/examples/toy/Ch7/toyc.cpp

if (isLoweringToAffine) {
 
     // Add a few cleanups post lowering.
     mlir::OpPassManager &optPM = pm.nest<mlir::func::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     // Add optimizations if enabled.
     if (enableOpt) {
-      optPM.addPass(mlir::createLoopFusionPass());
-      optPM.addPass(mlir::createAffineScalarReplacementPass());
+      optPM.addPass(mlir::affine::createLoopFusionPass());
+      optPM.addPass(mlir::affine::createAffineScalarReplacementPass());
     }
   }
 
   if (isLoweringToLLVM) {
     // Finish lowering the toy IR to the LLVM dialect.
     pm.addPass(mlir::toy::createLowerToLLVMPass());
     // This is necessary to have line tables emitted and basic
     // debugger working. In the future we will add proper debug information

mlir/include/mlir/Conversion/AffineToStandard/AffineToStandard.h

 //===- AffineToStandard.h - Convert Affine to Standard dialect --*- C++ -*-===//
 //
 // 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_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H
 #define MLIR_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
-class AffineForOp;
 class Location;
 struct LogicalResult;
 class OpBuilder;
 class Pass;
 class RewritePattern;
+class RewritePatternSet;
 class Value;
 class ValueRange;
 
-class RewritePatternSet;
+namespace affine {
+class AffineForOp;
+} // namespace affine
 
 #define GEN_PASS_DECL_CONVERTAFFINETOSTANDARD
 #include "mlir/Conversion/Passes.h.inc"
 
 /// Collect a set of patterns to convert from the Affine dialect to the Standard
 /// dialect, in particular convert structured affine control flow into CFG
 /// branch-based control flow.
 void populateAffineToStdConversionPatterns(RewritePatternSet &patterns);
 
 /// Collect a set of patterns to convert vector-related Affine ops to the Vector
 /// dialect.
 void populateAffineToVectorConversionPatterns(RewritePatternSet &patterns);
 
 /// Emit code that computes the lower bound of the given affine loop using
 /// standard arithmetic operations.
-Value lowerAffineLowerBound(AffineForOp op, OpBuilder &builder);
+Value lowerAffineLowerBound(affine::AffineForOp op, OpBuilder &builder);
 
 /// Emit code that computes the upper bound of the given affine loop using
 /// standard arithmetic operations.
-Value lowerAffineUpperBound(AffineForOp op, OpBuilder &builder);
+Value lowerAffineUpperBound(affine::AffineForOp op, OpBuilder &builder);
 
 /// Lowers affine control flow operations (ForStmt, IfStmt and AffineApplyOp)
 /// to equivalent lower-level constructs (flow of basic blocks and arithmetic
 /// primitives).
 std::unique_ptr<Pass> createLowerAffinePass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_AFFINETOSTANDARD_AFFINETOSTANDARD_H

mlir/include/mlir/Conversion/Passes.td

let options = [
     Option<"numThreadDims", "gpu-thread-dims", "unsigned", /*default=*/"1u",
            "Number of GPU thread dimensions for mapping">
   ];
 }
 
 def ConvertParallelLoopToGpu : Pass<"convert-parallel-loops-to-gpu"> {
   let summary = "Convert mapped scf.parallel ops to gpu launch operations";
   let constructor = "mlir::createParallelLoopToGpuPass()";
-  let dependentDialects = ["AffineDialect", "gpu::GPUDialect"];
+  let dependentDialects = ["affine::AffineDialect", "gpu::GPUDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeToStandard
 //===----------------------------------------------------------------------===//
 
 def ConvertShapeToStandard : Pass<"convert-shape-to-std", "ModuleOp"> {
   let summary = "Convert operations from the shape dialect into the standard "

 // VectorToGPU
 //===----------------------------------------------------------------------===//
 
 def ConvertVectorToGPU : Pass<"convert-vector-to-gpu"> {
   let summary = "Lower the operations from the vector dialect into the GPU "
                 "dialect";
   let constructor = "mlir::createConvertVectorToGPUPass()";
   let dependentDialects = [
-    "memref::MemRefDialect", "gpu::GPUDialect", "AffineDialect",
+    "memref::MemRefDialect", "gpu::GPUDialect", "affine::AffineDialect",
     "vector::VectorDialect", "nvgpu::NVGPUDialect"
   ];
 
   let options = [
     Option<"useNvGpu", "use-nvgpu", "bool", /*default=*/"false",
       "convert to NvGPU ops instead of GPU dialect ops">
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // VectorToSCF
 //===----------------------------------------------------------------------===//
 
 def ConvertVectorToSCF : Pass<"convert-vector-to-scf"> {
   let summary = "Lower the operations from the vector dialect into the SCF "
                 "dialect";
   let constructor = "mlir::createConvertVectorToSCFPass()";
   let dependentDialects = [
-    "AffineDialect",
+    "affine::AffineDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect",
     "tensor::TensorDialect"
   ];
   let options = [
     Option<"fullUnroll", "full-unroll", "bool", /*default=*/"false",
            "Perform full unrolling when converting vector transfers to SCF">,
     Option<"targetRank", "target-rank", "unsigned", /*default=*/"1",

mlir/include/mlir/Conversion/SCFToGPU/SCFToGPU.h

 //===- SCFToGPU.h - Convert loop nests to GPU kernels -----------*- C++ -*-===//
 //
 // 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_CONVERSION_SCFTOGPU_SCFTOGPU_H_
 #define MLIR_CONVERSION_SCFTOGPU_SCFTOGPU_H_
 
 #include "mlir/Support/LLVM.h"
 
 namespace mlir {
-class AffineForOp;
 class ConversionTarget;
 struct LogicalResult;
 class MLIRContext;
 class Value;
 class Operation;
 class RewritePatternSet;
 
+namespace affine {
+class AffineForOp;
+} // namespace affine
+
 namespace scf {
 class ForOp;
 } // namespace scf
 
 /// Convert a perfect affine loop nest with the outermost loop identified by
 /// `forOp` into a gpu::Launch operation.  Map `numBlockDims` outer loops to
 /// GPU blocks and `numThreadDims` to GPU threads.  The bounds of the loops that
 /// are mapped should be independent of the induction variables of the other
 /// mapped loops.
 ///
 /// No check on the size of the block or grid, or on the validity of
 /// parallelization is performed, it is under the responsibility of the caller
 /// to strip-mine the loops and to perform the dependence analysis before
 /// calling the conversion.
 
 // TODO: Consider removing this in favor of affine.for -> affine.parallel
 // detection followed by an affine.parallel -> scf.parallel -> gpu.launch
 // conversion
-LogicalResult convertAffineLoopNestToGPULaunch(AffineForOp forOp,
+LogicalResult convertAffineLoopNestToGPULaunch(affine::AffineForOp forOp,
                                                unsigned numBlockDims,
                                                unsigned numThreadDims);
 
 /// Adds the conversion pattern from `scf.parallel` to `gpu.launch` to the
 /// provided pattern list.
 void populateParallelLoopToGPUPatterns(RewritePatternSet &patterns);
 
 /// Configures the rewrite target such that only `scf.parallel` operations that

mlir/include/mlir/Dialect/Affine/Analysis/AffineAnalysis.h

 #define MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H
 
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/SmallVector.h"
 #include <optional>
 
 namespace mlir {
+class Operation;
 
+namespace affine {
 class AffineApplyOp;
 class AffineForOp;
 class AffineValueMap;
 class FlatAffineRelation;
 class FlatAffineValueConstraints;
-class Operation;
 
 /// A description of a (parallelizable) reduction in an affine loop.
 struct LoopReduction {
   /// Reduction kind.
   arith::AtomicRMWKind kind;
 
   /// Position of the iteration argument that acts as accumulator.
   unsigned iterArgPosition;

 
 /// Returns in 'depCompsVec', dependence components for dependences between all
 /// load and store ops in loop nest rooted at 'forOp', at loop depths in range
 /// [1, maxLoopDepth].
 void getDependenceComponents(
     AffineForOp forOp, unsigned maxLoopDepth,
     std::vector<SmallVector<DependenceComponent, 2>> *depCompsVec);
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_ANALYSIS_AFFINEANALYSIS_H

mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h

 #include "mlir/Analysis/Presburger/IntegerRelation.h"
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Support/LogicalResult.h"
 #include <optional>
 
 namespace mlir {
-
-class AffineCondition;
-class AffineForOp;
-class AffineIfOp;
-class AffineParallelOp;
 class AffineMap;
-class AffineValueMap;
 class IntegerSet;
-class MLIRContext;
-class Value;
 class MemRefType;
+class MLIRContext;
 struct MutableAffineMap;
+class Value;
 
 namespace presburger {
 class MultiAffineFunction;
 } // namespace presburger
 
+namespace affine {
+class AffineCondition;
+class AffineForOp;
+class AffineIfOp;
+class AffineParallelOp;
+class AffineValueMap;
+
 /// FlatAffineValueConstraints is an extension of FlatLinearValueConstraints
 /// with helper functions for Affine dialect ops.
 class FlatAffineValueConstraints : public FlatLinearValueConstraints {
 public:
   using FlatLinearValueConstraints::FlatLinearValueConstraints;
 
   /// Return the kind of this object.
   Kind getKind() const override { return Kind::FlatAffineValueConstraints; }

 ///
 /// For AffineValueMap, the domain and symbols have Value set corresponding to
 /// the Value in `map`. Returns failure if the AffineMap could not be flattened
 /// (i.e., semi-affine is not yet handled).
 LogicalResult getRelationFromMap(AffineMap &map, FlatAffineRelation &rel);
 LogicalResult getRelationFromMap(const AffineValueMap &map,
                                  FlatAffineRelation &rel);
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_ANALYSIS_AFFINESTRUCTURES_H

mlir/include/mlir/Dialect/Affine/Analysis/LoopAnalysis.h

 #ifndef MLIR_DIALECT_AFFINE_ANALYSIS_LOOPANALYSIS_H
 #define MLIR_DIALECT_AFFINE_ANALYSIS_LOOPANALYSIS_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include <optional>
 
 namespace mlir {
-
 class AffineExpr;
-class AffineForOp;
 class AffineMap;
 class BlockArgument;
 class MemRefType;
-class NestedPattern;
 class Operation;
 class Value;
 
+namespace affine {
+class AffineForOp;
+class NestedPattern;
+
 /// Returns the trip count of the loop as an affine map with its corresponding
 /// operands if the latter is expressible as an affine expression, and nullptr
 /// otherwise. This method always succeeds as long as the lower bound is not a
 /// multi-result map. The trip count expression is simplified before returning.
 /// This method only utilizes map composition to construct lower and upper
 /// bounds before computing the trip count expressions
 void getTripCountMapAndOperands(AffineForOp forOp, AffineMap *map,
                                 SmallVectorImpl<Value> *operands);

 
 /// Checks where SSA dominance would be violated if a for op's body
 /// operations are shifted by the specified shifts. This method checks if a
 /// 'def' and all its uses have the same shift factor.
 // TODO: extend this to check for memory-based dependence violation when we have
 // the support.
 bool isOpwiseShiftValid(AffineForOp forOp, ArrayRef<uint64_t> shifts);
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_ANALYSIS_LOOPANALYSIS_H

mlir/include/mlir/Dialect/Affine/Analysis/NestedMatcher.h

 //===- NestedMacher.h - Nested matcher for Function -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_AFFINE_ANALYSIS_NESTEDMATCHER_H
 #define MLIR_DIALECT_AFFINE_ANALYSIS_NESTEDMATCHER_H
 
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Operation.h"
 #include "llvm/Support/Allocator.h"
 
 namespace mlir {
+class Operation;
 
+namespace affine {
 class NestedPattern;
-class Operation;
 
 /// An NestedPattern captures nested patterns in the IR.
 /// It is used in conjunction with a scoped NestedPatternContext which is an
 /// llvm::BumpPtrAllocator that handles memory allocations efficiently and
 /// avoids ownership issues.
 ///
 /// In order to use NestedPatterns, first create a scoped context.
 /// When the context goes out of scope, everything is freed.

 NestedPattern For(const FilterFunctionType &filter,
                   ArrayRef<NestedPattern> nested = {});
 
 bool isParallelLoop(Operation &op);
 bool isReductionLoop(Operation &op);
 bool isLoadOrStore(Operation &op);
 
 } // namespace matcher
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_ANALYSIS_NESTEDMATCHER_H

mlir/include/mlir/Dialect/Affine/Analysis/Utils.h

 #define MLIR_DIALECT_AFFINE_ANALYSIS_UTILS_H
 
 #include "mlir/Dialect/Affine/Analysis/AffineStructures.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include <memory>
 #include <optional>
 
 namespace mlir {
-
-class AffineForOp;
-class AffineValueMap;
 class Block;
 class Location;
-struct MemRefAccess;
 class Operation;
 class Value;
 
+namespace affine {
+class AffineForOp;
+class AffineValueMap;
+struct MemRefAccess;
+
 // LoopNestStateCollector walks loop nests and collects load and store
 // operations, and whether or not a region holding op other than ForOp and IfOp
 // was encountered in the loop nest.
 struct LoopNestStateCollector {
   SmallVector<AffineForOp, 4> forOps;
   SmallVector<Operation *, 4> loadOpInsts;
   SmallVector<Operation *, 4> storeOpInsts;
   bool hasNonAffineRegionOp = false;

 
 /// Try to simplify the given affine.min or affine.max op to an affine map with
 /// a single result and operands, taking into account the specified constraint
 /// set. Return failure if no simplified version could be found.
 FailureOr<AffineValueMap>
 simplifyConstrainedMinMaxOp(Operation *op,
                             FlatAffineValueConstraints constraints);
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_ANALYSIS_UTILS_H

mlir/include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h

 
 #ifndef MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPINTERFACES_H
 #define MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPINTERFACES_H
 
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
 
-namespace mlir {
 #include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h.inc"
-} // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPINTERFACES_H

mlir/include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td

 
 include "mlir/IR/OpBase.td"
 
 def AffineReadOpInterface : OpInterface<"AffineReadOpInterface"> {
   let description = [{
       Interface to query characteristics of read-like ops with affine
       restrictions.
   }];
+  let cppNamespace = "::mlir::affine";
 
   let methods = [
     InterfaceMethod<
       /*desc=*/"Returns the memref operand to read from.",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getMemRef",
       /*args=*/(ins),
       /*methodBody*/[{}],
       /*defaultImplementation=*/ [{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getOperand(op.getMemRefOperandIndex());
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Returns the type of the memref operand.",
-      /*retTy=*/"MemRefType",
+      /*retTy=*/"::mlir::MemRefType",
       /*methodName=*/"getMemRefType",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
-        return op.getMemRef().getType().template cast<MemRefType>();
+        return op.getMemRef().getType().template cast<::mlir::MemRefType>();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Returns affine map operands.",
-      /*retTy=*/"Operation::operand_range",
+      /*retTy=*/"::mlir::Operation::operand_range",
       /*methodName=*/"getMapOperands",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return llvm::drop_begin(op.getOperands(), 1);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Returns the affine map used to index the memref for this operation.
       }],
-      /*retTy=*/"AffineMap",
+      /*retTy=*/"::mlir::AffineMap",
       /*methodName=*/"getAffineMap",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getAffineMapAttr().getValue();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Returns the value read by this operation.",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getValue",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         return cast<ConcreteOp>(this->getOperation());
       }]
     >,
   ];
 }
 
 def AffineWriteOpInterface : OpInterface<"AffineWriteOpInterface"> {
   let description = [{
       Interface to query characteristics of write-like ops with affine
       restrictions.
   }];
 
   let methods = [
     InterfaceMethod<
       /*desc=*/"Returns the memref operand to write to.",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getMemRef",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getOperand(op.getMemRefOperandIndex());
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Returns the type of the memref operand.",
-      /*retTy=*/"MemRefType",
+      /*retTy=*/"::mlir::MemRefType",
       /*methodName=*/"getMemRefType",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
-        return op.getMemRef().getType().template cast<MemRefType>();
+        return op.getMemRef().getType().template cast<::mlir::MemRefType>();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Returns affine map operands.",
-      /*retTy=*/"Operation::operand_range",
+      /*retTy=*/"::mlir::Operation::operand_range",
       /*methodName=*/"getMapOperands",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return llvm::drop_begin(op.getOperands(), 2);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Returns the affine map used to index the memref for this operation.
       }],
-      /*retTy=*/"AffineMap",
+      /*retTy=*/"::mlir::AffineMap",
       /*methodName=*/"getAffineMap",
       /*args=*/(ins),
       /*methodName=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getAffineMapAttr().getValue();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Returns the value to store.",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getValueToStore",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getOperand(op.getStoredValOperandIndex());
       }]
     >,
   ];
 }
 
 def AffineMapAccessInterface : OpInterface<"AffineMapAccessInterface"> {
   let description = [{
       Interface to query the AffineMap used to dereference and access a given
       memref. Implementers of this interface must operate on at least one
       memref operand.  The memref argument given to this interface much match
       one of those memref operands.
   }];
 
   let methods = [
     InterfaceMethod<
       /*desc=*/"Returns the AffineMapAttr associated with 'memref'.",
-      /*retTy=*/"NamedAttribute",
+      /*retTy=*/"::mlir::NamedAttribute",
       /*methodName=*/"getAffineMapAttrForMemRef",
-      /*args=*/(ins "Value":$memref),
+      /*args=*/(ins "::mlir::Value":$memref),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         assert(memref == op.getMemRef() &&
                "Expected memref argument to match memref operand");
-        return {StringAttr::get(op.getContext(), op.getMapAttrStrName()),
-                op.getAffineMapAttr()};
+        return {
+            ::mlir::StringAttr::get(op.getContext(), op.getMapAttrStrName()),
       }]
     >,
   ];
 }
 
 #endif // AFFINEMEMORYOPINTERFACES

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

 #include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 
 namespace mlir {
+namespace affine {
+
 class AffineApplyOp;
 class AffineBound;
 class AffineValueMap;
 
-/// TODO: These should be renamed if they are on the mlir namespace.
-///       Ideally, they should go in a mlir::affine:: namespace.
-
 /// A utility function to check if a value is defined at the top level of an
 /// op with trait `AffineScope` or is a region argument for such an op. A value
 /// of index type defined at the top level is always a valid symbol for all its
 /// uses.
 bool isTopLevelValue(Value value);
 
 /// A utility function to check if a value is defined at the top level of
 /// `region` or is an argument of `region`. A value of index type defined at the

 /// into `map`, maps of AffineApplyOps whose results are the values in
 /// `operands`, iteratively until no more of `operands` are the result of an
 /// AffineApplyOp. When this function returns, `map` becomes the composed affine
 /// map, and each Value in `operands` is guaranteed to be either a loop IV or a
 /// terminal symbol, i.e., a symbol defined at the top level or a block/function
 /// argument.
 void fullyComposeAffineMapAndOperands(AffineMap *map,
                                       SmallVectorImpl<Value> *operands);
+
+} // namespace affine
 } // namespace mlir
+
 #include "mlir/Dialect/Affine/IR/AffineOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Affine/IR/AffineOps.h.inc"
 
 namespace mlir {
+namespace affine {
+
 /// Returns true if the provided value is the induction variable of an
 /// AffineForOp.
 bool isAffineForInductionVar(Value val);
 
 /// Returns true if `val` is the induction variable of an AffineParallelOp.
 bool isAffineParallelInductionVar(Value val);
 
 /// Returns true if the provided value is the induction variable of an
private:
   AffineMap map;
 
   AffineBound(AffineForOp op, unsigned opStart, unsigned opEnd, AffineMap map)
       : op(op), opStart(opStart), opEnd(opEnd), map(map) {}
 
   friend class AffineForOp;
 };
 
+} // namespace affine
 } // namespace mlir
 
 #endif

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

 include "mlir/Dialect/Arith/IR/ArithBase.td"
 include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Affine_Dialect : Dialect {
   let name = "affine";
-  let cppNamespace = "mlir";
+  let cppNamespace = "::mlir::affine";
   let hasConstantMaterializer = 1;
   let dependentDialects = ["arith::ArithDialect"];
 }
 
 // Base class for Affine dialect ops.
 class Affine_Op<string mnemonic, list<Trait> traits = []> :
     Op<Affine_Dialect, mnemonic, traits>;
 

mlir/include/mlir/Dialect/Affine/IR/AffineValueMap.h

 #ifndef MLIR_DIALECT_AFFINE_IR_AFFINEVALUEMAP_H
 #define MLIR_DIALECT_AFFINE_IR_AFFINEVALUEMAP_H
 
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/Value.h"
 
 namespace mlir {
+namespace affine {
 
 /// An AffineValueMap is an affine map plus its ML value operands and
 /// results for analysis purposes. The structure is still a tree form that is
 /// same as that of an affine map or an AffineApplyOp. However, its operands,
 /// results, and its map can themselves change  as a result of
 /// substitutions, simplifications, and other analysis.
 // An affine value map can readily be constructed from an AffineApplyOp, or an
 // AffineBound of a AffineForOp. It can be further transformed, substituted
private:
 
   // TODO: make these trailing objects?
   /// The SSA operands binding to the dim's and symbols of 'map'.
   SmallVector<Value, 4> operands;
   /// The SSA results binding to the results of 'map'.
   SmallVector<Value, 4> results;
 };
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_IR_AFFINEVALUEMAP_H

mlir/include/mlir/Dialect/Affine/LoopFusionUtils.h

 #define MLIR_DIALECT_AFFINE_LOOPFUSIONUTILS_H
 
 #include "mlir/IR/Value.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
 namespace mlir {
+class Operation;
+
+namespace affine {
 class AffineForOp;
 struct ComputationSliceState;
-class Operation;
 
 // TODO: Extend this module to include utility functions for querying fusion
 // cost/storage reduction, and for performing the loop fusion transformation.
 
 struct FusionResult {
   enum ResultEnum {
     Success,
     FailPrecondition,     // Failed precondition for fusion. (e.g. same block).
bool getFusionComputeCost(AffineForOp srcForOp, LoopNestStats &srcStats,
                           int64_t *computeCost);
 
 /// Returns in 'producerConsumerMemrefs' the memrefs involved in a
 /// producer-consumer dependence between write ops in 'srcOps' and read ops in
 /// 'dstOps'.
 void gatherProducerConsumerMemrefs(ArrayRef<Operation *> srcOps,
                                    ArrayRef<Operation *> dstOps,
                                    DenseSet<Value> &producerConsumerMemrefs);
+
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_LOOPFUSIONUTILS_H

mlir/include/mlir/Dialect/Affine/LoopUtils.h

 
 #include "mlir/IR/Block.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include <optional>
 
 namespace mlir {
-class AffineForOp;
 class AffineMap;
 class LoopLikeOpInterface;
-struct MemRefRegion;
 class OpBuilder;
 class Value;
 class ValueRange;
 
 namespace func {
 class FuncOp;
 } // namespace func
 
 namespace scf {
 class ForOp;
 class ParallelOp;
 } // namespace scf
 
+namespace affine {
+class AffineForOp;
+struct MemRefRegion;
+
 /// Unrolls this for operation completely if the trip count is known to be
 /// constant. Returns failure otherwise.
 LogicalResult loopUnrollFull(AffineForOp forOp);
 
 /// Unrolls this for operation by the specified unroll factor. Returns failure
 /// if the loop cannot be unrolled either due to restrictions or due to invalid
 /// unroll factors. Requires positive loop bounds and step. If specified,
 /// annotates the Ops in each unrolled iteration by applying `annotateFn`.
for (unsigned end = loops.size(); end > 0; --end) {
     // If a band was found and transformed, keep looking at the loops above
     // the outermost transformed loop.
     if (start != end - 1)
       end = start + 1;
   }
   return result;
 }
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_LOOPUTILS_H

mlir/include/mlir/Dialect/Affine/Passes.h

 #include <limits>
 
 namespace mlir {
 
 namespace func {
 class FuncOp;
 } // namespace func
 
+namespace affine {
 class AffineForOp;
 
 /// Fusion mode to attempt. The default mode `Greedy` does both
 /// producer-consumer and sibling fusion.
 enum FusionMode { Greedy, ProducerConsumer, Sibling };
 
 #define GEN_PASS_DECL
 #include "mlir/Dialect/Affine/Passes.h.inc"

 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Affine/Passes.h.inc"
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_PASSES_H

mlir/include/mlir/Dialect/Affine/Passes.td

 
 #ifndef MLIR_DIALECT_AFFINE_PASSES
 #define MLIR_DIALECT_AFFINE_PASSES
 
 include "mlir/Pass/PassBase.td"
 
 def AffineDataCopyGeneration : Pass<"affine-data-copy-generate", "func::FuncOp"> {
   let summary = "Generate explicit copying for affine memory operations";
-  let constructor = "mlir::createAffineDataCopyGenerationPass()";
+  let constructor = "mlir::affine::createAffineDataCopyGenerationPass()";
   let dependentDialects = ["memref::MemRefDialect"];
   let options = [
     Option<"fastMemoryCapacity", "fast-mem-capacity", "uint64_t",
            /*default=*/"std::numeric_limits<uint64_t>::max()",
            "Set fast memory space capacity in KiB (default: unlimited)">,
     Option<"fastMemorySpace", "fast-mem-space", "unsigned",
            /*default=*/"1",
            "Fast memory space identifier for copy generation (default: 1)">,
func.func @sibling_fusion(%arg0: memref<10x10xf32>, %arg1: memref<10x10xf32>,
           %5 = arith.addf %3, %4 : f32
           affine.store %5, %arg4[%arg5, %arg6] : memref<10x10xf32>
         }
       }
       return
     }
     ```
   }];
-  let constructor = "mlir::createLoopFusionPass()";
+  let constructor = "mlir::affine::createLoopFusionPass()";
   let options = [
     Option<"computeToleranceThreshold", "fusion-compute-tolerance", "double",
            /*default=*/"0.30f", "Fractional increase in additional computation "
                                 "tolerated while fusing">,
     Option<"fastMemorySpace", "fusion-fast-mem-space", "unsigned",
            /*default=*/"0",
            "Faster memory space number to promote fusion buffers to">,
     Option<"localBufSizeThreshold", "fusion-local-buf-threshold", "uint64_t",
            /*default=*/"0", "Threshold size (KiB) for promoting local buffers "
                             "to fast memory space">,
     Option<"maximalFusion", "fusion-maximal", "bool", /*default=*/"false",
            "Enables maximal loop fusion">,
     Option<"affineFusionMode", "mode", "enum FusionMode",
-           "mlir::FusionMode::Greedy", "fusion mode to attempt",
-           "llvm::cl::values(clEnumValN(mlir::FusionMode::Greedy,"
+           "mlir::affine::FusionMode::Greedy", "fusion mode to attempt",
+           "llvm::cl::values(clEnumValN(mlir::affine::FusionMode::Greedy,"
            " \"greedy\", \"Perform greedy (both producer-consumer and sibling)  fusion\"), "
-           "clEnumValN( mlir::FusionMode::ProducerConsumer, "
+           "clEnumValN( mlir::affine::FusionMode::ProducerConsumer, "
            "\"producer\", \"Perform only producer-consumer fusion\"), "
-           "clEnumValN( mlir::FusionMode::Sibling, "
+           "clEnumValN( mlir::affine::FusionMode::Sibling, "
            "\"sibling\", \"Perform only sibling fusion\"))">,
     ];
   let dependentDialects = ["memref::MemRefDialect"];
 }
 
 def AffineLoopInvariantCodeMotion
     : Pass<"affine-loop-invariant-code-motion", "func::FuncOp"> {
   let summary = "Hoist loop invariant instructions outside of affine loops";
-  let constructor = "mlir::createAffineLoopInvariantCodeMotionPass()";
+  let constructor = "mlir::affine::createAffineLoopInvariantCodeMotionPass()";
 }
 
 def AffineLoopTiling : Pass<"affine-loop-tile", "func::FuncOp"> {
   let summary = "Tile affine loop nests";
-  let constructor = "mlir::createLoopTilingPass()";
+  let constructor = "mlir::affine::createLoopTilingPass()";
   let options = [
     Option<"cacheSizeInKiB", "cache-size", "uint64_t", /*default=*/"512",
            "Set size of cache to tile for in KiB (default: 512)">,
     Option<"separate", "separate", "bool", /*default=*/"false",
            "Separate full and partial tiles (default: false)">,
     Option<"tileSize", "tile-size", "unsigned", /*default=*/"",
            "Use this tile size for all loops">,
     ListOption<"tileSizes", "tile-sizes", "unsigned",
                "List of tile sizes for each perfect nest "
                "(overridden by -tile-size)">,
   ];
 }
 
 def AffineLoopUnroll : Pass<"affine-loop-unroll", "func::FuncOp"> {
   let summary = "Unroll affine loops";
-  let constructor = "mlir::createLoopUnrollPass()";
+  let constructor = "mlir::affine::createLoopUnrollPass()";
   let options = [
     Option<"unrollFactor", "unroll-factor", "unsigned", /*default=*/"4",
            "Use this unroll factor for all loops being unrolled">,
     Option<"unrollUpToFactor", "unroll-up-to-factor", "bool",
            /*default=*/"false", "Allow unrolling up to the factor specified">,
     Option<"unrollFull", "unroll-full", "bool", /*default=*/"false",
            "Fully unroll loops">,
     Option<"numRepetitions", "unroll-num-reps", "unsigned", /*default=*/"1",
            "Unroll innermost loops repeatedly this many times">,
     Option<"unrollFullThreshold", "unroll-full-threshold", "unsigned",
            /*default=*/"1",
            "Unroll all loops with trip count less than or equal to this">,
     Option<"cleanUpUnroll", "cleanup-unroll", "bool", /*default=*/"false",
            "Fully unroll the cleanup loop when possible.">,
   ];
 }
 
 def AffineLoopUnrollAndJam : Pass<"affine-loop-unroll-jam", "func::FuncOp"> {
   let summary = "Unroll and jam affine loops";
-  let constructor = "mlir::createLoopUnrollAndJamPass()";
+  let constructor = "mlir::affine::createLoopUnrollAndJamPass()";
   let options = [
     Option<"unrollJamFactor", "unroll-jam-factor", "unsigned",
            /*default=*/"4",
            "Use this unroll jam factor for all loops (default 4)">,
   ];
 }
 
 def AffinePipelineDataTransfer
module {
         affine.store %7, %1[%3 mod 2, %3] : memref<2x32xf32, 1>
         memref.dealloc %2 : memref<2x1xf32>
         memref.dealloc %1 : memref<2x32xf32, 1>
         return
       }
     }
     ```
   }];
-  let constructor = "mlir::createPipelineDataTransferPass()";
+  let constructor = "mlir::affine::createPipelineDataTransferPass()";
 }
 
 def AffineScalarReplacement : Pass<"affine-scalrep", "func::FuncOp"> {
   let summary = "Replace affine memref accesses by scalars by forwarding stores "
                 "to loads and eliminating redundant loads";
   let description = [{
     This pass performs store to load forwarding and redundant load elimination
     for affine memref accesses and potentially eliminates the entire memref
module {
             %1 = arith.addf %cst, %cst : f32
           }
         }
         return %0 : memref<10x10xf32>
       }
     }
     ```
   }];
-  let constructor = "mlir::createAffineScalarReplacementPass()";
+  let constructor = "mlir::affine::createAffineScalarReplacementPass()";
 }
 
 def AffineVectorize : Pass<"affine-super-vectorize", "func::FuncOp"> {
   let summary = "Vectorize to a target independent n-D vector abstraction";
   let dependentDialects = ["vector::VectorDialect"];
   let options = [
     ListOption<"vectorSizes", "virtual-vector-size", "int64_t",
                "Specify an n-D virtual vector size for vectorization">,
Option<"vectorizeReductions", "vectorize-reductions", "bool",
            /*default=*/"false",
            "Vectorize known reductions expressed via iter_args. "
            "Switched off by default.">
   ];
 }
 
 def AffineParallelize : Pass<"affine-parallelize", "func::FuncOp"> {
   let summary = "Convert affine.for ops into 1-D affine.parallel";
-  let constructor = "mlir::createAffineParallelizePass()";
+  let constructor = "mlir::affine::createAffineParallelizePass()";
   let options = [
     Option<"maxNested", "max-nested", "unsigned", /*default=*/"-1u",
            "Maximum number of nested parallel loops to produce. "
            "Defaults to unlimited (UINT_MAX).">,
     Option<"parallelReductions", "parallel-reductions", "bool",
            /*default=*/"false",
            "Whether to parallelize reduction loops. Defaults to false.">
   ];
 }
 
 def AffineLoopNormalize : Pass<"affine-loop-normalize", "func::FuncOp"> {
   let summary = "Apply normalization transformations to affine loop-like ops";
-  let constructor = "mlir::createAffineLoopNormalizePass()";
+  let constructor = "mlir::affine::createAffineLoopNormalizePass()";
   let options = [
     Option<"promoteSingleIter", "promote-single-iter", "bool",
            /*default=*/"true", "Promote single iteration loops">,
   ];
 }
 
 def LoopCoalescing : Pass<"affine-loop-coalescing", "func::FuncOp"> {
   let summary = "Coalesce nested loops with independent bounds into a single "
                 "loop";
-  let constructor = "mlir::createLoopCoalescingPass()";
+  let constructor = "mlir::affine::createLoopCoalescingPass()";
   let dependentDialects = ["arith::ArithDialect"];
 }
 
 def SimplifyAffineStructures : Pass<"affine-simplify-structures", "func::FuncOp"> {
   let summary = "Simplify affine expressions in maps/sets and normalize "
                 "memrefs";
-  let constructor = "mlir::createSimplifyAffineStructuresPass()";
+  let constructor = "mlir::affine::createSimplifyAffineStructuresPass()";
 }
 
 def AffineExpandIndexOps : Pass<"affine-expand-index-ops"> {
   let summary = "Lower affine operations operating on indices into more fundamental operations";
-  let constructor = "mlir::createAffineExpandIndexOpsPass()";
+  let constructor = "mlir::affine::createAffineExpandIndexOpsPass()";
 }
 
 #endif // MLIR_DIALECT_AFFINE_PASSES

mlir/include/mlir/Dialect/Affine/TransformOps/AffineTransformOps.h

 #define MLIR_DIALECT_AFFINE_TRANSFORMOPS_AFFINETRANSFORMOPS_H
 
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformTypes.h"
 #include "mlir/IR/OpImplementation.h"
 
 namespace mlir {
-class AffineForOp;
 namespace func {
 class FuncOp;
 } // namespace func
 namespace affine {
-class ForOp;
+class AffineForOp;
 } // namespace affine
 } // namespace mlir
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Affine/TransformOps/AffineTransformOps.h.inc"
 
 namespace mlir {
 class DialectRegistry;
 
 namespace affine {
 void registerTransformDialectExtension(DialectRegistry &registry);
 } // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_TRANSFORMOPS_AFFINETRANSFORMOPS_H

mlir/include/mlir/Dialect/Affine/Transforms/Transforms.h

 
 #ifndef MLIR_DIALECT_AFFINE_TRANSFORMS_TRANSFORMS_H
 #define MLIR_DIALECT_AFFINE_TRANSFORMS_TRANSFORMS_H
 
 #include "mlir/Interfaces/ValueBoundsOpInterface.h"
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
-class AffineApplyOp;
 class Location;
 class OpBuilder;
 class OpFoldResult;
 class RewritePatternSet;
 class RewriterBase;
 class Value;
 
 namespace presburger {
 enum class BoundType;
 } // namespace presburger
 
+namespace affine {
+class AffineApplyOp;
+
 /// Populate patterns that expand affine index operations into more fundamental
 /// operations (not necessarily restricted to Affine dialect).
 void populateAffineExpandIndexOpsPatterns(RewritePatternSet &patterns);
 
 /// Helper function to rewrite `op`'s affine map and reorder its operands such
 /// that they are in increasing order of hoistability (i.e. the least hoistable)
 /// operands come first in the operand list.
 void reorderOperandsByHoistability(RewriterBase &rewriter, AffineApplyOp op);

 /// * Otherwise, if the owners of %a, %b or %c do not implement the
 ///   ValueBoundsOpInterface, no bound can be computed.
 FailureOr<OpFoldResult>
 reifyValueBound(OpBuilder &b, Location loc, presburger::BoundType type,
                 Value value, std::optional<int64_t> dim,
                 ValueBoundsConstraintSet::StopConditionFn stopCondition,
                 bool closedUB = false);
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_TRANSFORMS_TRANSFORMS_H

mlir/include/mlir/Dialect/Affine/Utils.h

 #ifndef MLIR_DIALECT_AFFINE_UTILS_H
 #define MLIR_DIALECT_AFFINE_UTILS_H
 
 #include "mlir/Dialect/Affine/Analysis/AffineAnalysis.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include <optional>
 
 namespace mlir {
-
-class AffineForOp;
-class AffineIfOp;
-class AffineParallelOp;
 class DominanceInfo;
 class Operation;
 class PostDominanceInfo;
 
 namespace func {
 class FuncOp;
 } // namespace func
 
 namespace memref {
 class AllocOp;
 } // namespace memref
 
 struct LogicalResult;
 
+namespace affine {
+class AffineForOp;
+class AffineIfOp;
+class AffineParallelOp;
+
 using ReductionLoopMap = DenseMap<Operation *, SmallVector<LoopReduction, 2>>;
 
 /// Replaces a parallel affine.for op with a 1-d affine.parallel op. `forOp`'s
 /// body is taken by the affine.parallel op and the former is erased.
 /// (mlir::isLoopParallel can be used to detect a parallel affine.for op.) The
 /// reductions specified in `parallelReductions` are also parallelized.
 /// Parallelization will fail in the presence of loop iteration arguments that
 /// are not listed in `parallelReductions`.
return makeComposedFoldedAffineMax(
         vals);
   }
 
 private:
   OpBuilder &b;
   Location loc;
 };
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_UTILS_H

mlir/include/mlir/Dialect/Affine/ViewLikeInterfaceUtils.h

 
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 namespace mlir {
 class RewriterBase;
 
+namespace affine {
+
 /// Fills the `combinedOffsets`, `combinedSizes` and `combinedStrides` to use
 /// when combining a producer slice **into** a consumer slice.
 ///
 /// This function performs the following computation:
 /// - Combined offsets = producer_offsets * consumer_strides + consumer_offsets
 /// - Combined sizes = consumer_sizes
 /// - Combined strides = producer_strides * consumer_strides
 // TODO: unify this API with resolveIndicesIntoOpWithOffsetsAndStrides or

 /// In practice, this amounts to filtering by `rankReducedSourceDims` and taking
 /// from `sourceSizes` if a dimension is dropped, otherwise taking from
 /// `destSizes`.
 void resolveSizesIntoOpWithSizes(
     ArrayRef<OpFoldResult> sourceSizes, ArrayRef<OpFoldResult> destSizes,
     const llvm::SmallBitVector &rankReducedSourceDims,
     SmallVectorImpl<OpFoldResult> &resolvedSizes);
 
+} // namespace affine
 } // namespace mlir
 
 #endif // MLIR_DIALECT_AFFINE_VIEWLIKEINTERFACEUTILS_H

mlir/include/mlir/Dialect/Bufferization/IR/BufferizationBase.td

let description = [{
     specific to the bufferization passes.
 
     Overview of the bufferization infrastructure and important conceptual
     details related to using the MLIR dialect conversion infrastructure can be
     found in [bufferization](/docs/Bufferization/) and [buffer
     deallocation](/docs/BufferDeallocationInternals/).
   }];
   let dependentDialects = [
-    "AffineDialect", "memref::MemRefDialect", "tensor::TensorDialect"
+    "affine::AffineDialect", "memref::MemRefDialect", "tensor::TensorDialect"
   ];
 
   let extraClassDeclaration = [{
     /// Verify an attribute from this dialect on the argument at 'argIndex' for
     /// the region at 'regionIndex' on the given operation. Returns failure if
     /// the verification failed, success otherwise. This hook may optionally be
     /// invoked from any operation containing a region.
     LogicalResult verifyRegionArgAttribute(Operation *,

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

let description = [{
     [Rationale
     Document](https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect) are
     are also available and should be read first before going in the details of
     the op semantics.
   }];
   let cppNamespace = "::mlir::linalg";
   let dependentDialects = [
     "arith::ArithDialect",
-    "AffineDialect",
+    "affine::AffineDialect",
     "math::MathDialect",
     "memref::MemRefDialect",
     "tensor::TensorDialect",
   ];
   let useDefaultAttributePrinterParser = 1;
   let hasCanonicalizer = 1;
   let hasOperationAttrVerify = 1;
   let hasConstantMaterializer = 1;

mlir/include/mlir/Dialect/Linalg/Passes.td

Option<"foldOneTripLoopsOnly", "fold-one-trip-loops-only", "bool",
             /*default=*/"false",
            "Only folds the one-trip loops from Linalg ops on tensors "
            "(for testing purposes only)">,
     Option<"useRankReducingSlices", "use-rank-reducing-slices", "bool",
            /*default=*/"false",
            "Generate rank-reducing slices instead of reassociative reshapes">
   ];
   let dependentDialects = [
-    "linalg::LinalgDialect", "AffineDialect", "memref::MemRefDialect"
+    "linalg::LinalgDialect", "affine::AffineDialect", "memref::MemRefDialect"
   ];
 }
 
 def LinalgElementwiseOpFusion : Pass<"linalg-fuse-elementwise-ops"> {
   let summary = "Fuse elementwise operations on tensors";
   let constructor = "mlir::createLinalgElementwiseOpFusionPass()";
   let dependentDialects = [
-    "AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"
+    "affine::AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"
   ];
 }
 
 def LinalgNamedOpConversion: Pass<"linalg-named-op-conversion"> {
   let summary = "Convert from one named linalg op to another.";
   let constructor = "mlir::createLinalgNamedOpConversionPass()";
   let dependentDialects = ["linalg::LinalgDialect", "tensor::TensorDialect"];
 }
 
 def LinalgInlineScalarOperands : Pass<"linalg-inline-scalar-operands", "func::FuncOp"> {
   let summary = "Inline scalar operands into linalg generic ops";
   let constructor = "mlir::createLinalgInlineScalarOperandsPass()";
   let dependentDialects = [
     "linalg::LinalgDialect"
   ];
 }
 
 def LinalgLowerToAffineLoops : Pass<"convert-linalg-to-affine-loops", "func::FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into affine "
                 "loops";
   let constructor = "mlir::createConvertLinalgToAffineLoopsPass()";
   let dependentDialects = [
-    "AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"];
+    "affine::AffineDialect", "linalg::LinalgDialect", "memref::MemRefDialect"];
 }
 
 def LinalgLowerToLoops : Pass<"convert-linalg-to-loops", "func::FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into loops";
   let constructor = "mlir::createConvertLinalgToLoopsPass()";
   let dependentDialects = [
     "linalg::LinalgDialect",
     "scf::SCFDialect",
-    "AffineDialect"
+    "affine::AffineDialect"
   ];
 }
 
 def LinalgLowerToParallelLoops
     : Pass<"convert-linalg-to-parallel-loops", "func::FuncOp"> {
   let summary = "Lower the operations from the linalg dialect into parallel "
                 "loops";
   let constructor = "mlir::createConvertLinalgToParallelLoopsPass()";
   let dependentDialects = [
-    "AffineDialect",
+    "affine::AffineDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect"
   ];
 }
 
 def LinalgBufferize : Pass<"linalg-bufferize", "func::FuncOp"> {
   let summary = "Bufferize the linalg dialect";
   let constructor = "mlir::createLinalgBufferizePass()";
   let dependentDialects = [
-    "AffineDialect",
+    "affine::AffineDialect",
     "bufferization::BufferizationDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
   ];
 }
 
 def LinalgGeneralization : Pass<"linalg-generalize-named-ops", "func::FuncOp"> {
   let summary = "Convert named ops into generic ops";

mlir/include/mlir/Dialect/Linalg/Utils/Utils.h

 #include "mlir/Dialect/Linalg/Utils/IndexingUtils.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "llvm/ADT/StringSet.h"
 #include <optional>
 
 namespace mlir {
 class AffineExpr;
-class AffineForOp;
 class AffineMap;
 class PatternRewriter;
 
+namespace affine {
+class AffineForOp;
+} // namespace affine
+
 namespace tensor {
 class ExtractSliceOp;
 } // namespace tensor
 
 namespace linalg {
 
 //===----------------------------------------------------------------------===//
 // Utilities for inferring various semantics properties of Linalg ops.

mlir/include/mlir/Dialect/MemRef/Transforms/Passes.td

 def FoldMemRefAliasOps : Pass<"fold-memref-alias-ops"> {
   let summary = "Fold memref alias ops into consumer load/store ops";
   let description = [{
     The pass folds loading/storing from/to memref aliasing ops to loading/storing
     from/to the original memref.
   }];
   let constructor = "mlir::memref::createFoldMemRefAliasOpsPass()";
   let dependentDialects = [
-      "AffineDialect", "memref::MemRefDialect", "vector::VectorDialect"
+      "affine::AffineDialect", "memref::MemRefDialect", "vector::VectorDialect"
   ];
 }
 
 def MemRefEmulateWideInt : Pass<"memref-emulate-wide-int"> {
   let summary = "Emulate 2*N-bit integer operations using N-bit operations";
   let description = [{
     Emulate memref integer operations that use too wide integer types with
     equivalent operations on supported narrow integer types. This is done by
affine.for %arg3 = %c0 to %c8 {
         }
       }
     }
     return
   }
   ```
   }];
   let constructor = "mlir::memref::createNormalizeMemRefsPass()";
-  let dependentDialects = ["AffineDialect"];
+  let dependentDialects = ["affine::AffineDialect"];
 }
 
 def ResolveRankedShapeTypeResultDims :
     Pass<"resolve-ranked-shaped-type-result-dims"> {
   let summary = "Resolve memref.dim of result values of ranked shape type";
   let description = [{
     The pass resolves memref.dim of result of operations that
     implement the `ReifyRankedShapedTypeOpInterface` in terms of
def ResolveShapedTypeResultDims : Pass<"resolve-shaped-type-result-dims"> {
   let description = [{
     The pass resolves memref.dim of result of operations that
     implement the `InferShapedTypeOpInterface` or
     `ReifyRankedShapedTypeOpInterface` in terms of shapes of its
     operands.
   }];
   let constructor = "mlir::memref::createResolveShapedTypeResultDimsPass()";
   let dependentDialects = [
-    "AffineDialect", "memref::MemRefDialect", "tensor::TensorDialect"
+    "affine::AffineDialect", "memref::MemRefDialect", "tensor::TensorDialect"
   ];
 }
 
 def ExpandStridedMetadata : Pass<"expand-strided-metadata"> {
   let summary = "Expand memref operations into easier to analyze constructs";
   let description = [{
     The pass expands memref operations that modify the metadata of a memref
     (sizes, offset, strides) into a sequence of easier to analyze constructs.
     In particular, this pass transforms operations into explicit sequence of
     operations that model the effect of this operation on the different metadata.
     This pass uses affine constructs to materialize these effects.
   }];
   let constructor = "mlir::memref::createExpandStridedMetadataPass()";
   let dependentDialects = [
-      "AffineDialect", "memref::MemRefDialect"
+      "affine::AffineDialect", "memref::MemRefDialect"
   ];
 }
 #endif // MLIR_DIALECT_MEMREF_TRANSFORMS_PASSES
 

mlir/include/mlir/Dialect/SCF/Transforms/Passes.td

 }
 
 // Note: Making these canonicalization patterns would require a dependency
 // of the SCF dialect on the Affine/Tensor/MemRef dialects or vice versa.
 def SCFForLoopCanonicalization
     : Pass<"scf-for-loop-canonicalization"> {
   let summary = "Canonicalize operations within scf.for loop bodies";
   let constructor = "mlir::createSCFForLoopCanonicalizationPass()";
-  let dependentDialects = ["AffineDialect", "tensor::TensorDialect",
+  let dependentDialects = ["affine::AffineDialect", "tensor::TensorDialect",
                            "memref::MemRefDialect"];
 }
 
 def SCFForLoopPeeling : Pass<"scf-for-loop-peeling"> {
   let summary = "Peel `for` loops at their upper bounds.";
   let constructor = "mlir::createForLoopPeelingPass()";
   let options = [
     Option<"skipPartial", "skip-partial", "bool",
            /*default=*/"true",
            "Do not peel loops inside of the last, partial iteration of another "
            "already peeled loop.">
   ];
-  let dependentDialects = ["AffineDialect"];
+  let dependentDialects = ["affine::AffineDialect"];
 }
 
 def SCFForLoopSpecialization : Pass<"scf-for-loop-specialization"> {
   let summary = "Specialize `for` loops for vectorization";
   let constructor = "mlir::createForLoopSpecializationPass()";
 }
 
 def SCFParallelLoopFusion : Pass<"scf-parallel-loop-fusion"> {
def SCFParallelLoopTiling : Pass<"scf-parallel-loop-tiling"> {
   let options = [
     ListOption<"tileSizes", "parallel-loop-tile-sizes", "int64_t",
                "Factors to tile parallel loops by">,
     Option<"noMinMaxBounds", "no-min-max-bounds", "bool",
            /*default=*/"false",
            "Perform tiling with fixed upper bound with inbound check "
            "inside the internal loops">
   ];
-  let dependentDialects = ["AffineDialect"];
+  let dependentDialects = ["affine::AffineDialect"];
 }
 
 def SCFForLoopRangeFolding : Pass<"scf-for-loop-range-folding"> {
   let summary = "Fold add/mul ops into loop range";
   let constructor = "mlir::createForLoopRangeFoldingPass()";
 }
 
 def SCFForToWhileLoop : Pass<"scf-for-to-while"> {

mlir/include/mlir/Dialect/SCF/Utils/AffineCanonicalizationUtils.h

 
 #ifndef MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
 #define MLIR_DIALECT_SCF_UTILS_AFFINECANONICALIZATIONUTILS_H_
 
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
-class AffineApplyOp;
 class AffineMap;
-class FlatAffineValueConstraints;
 struct LogicalResult;
 class Operation;
 class OpFoldResult;
 class RewriterBase;
 class Value;
 class ValueRange;
 
+namespace affine {
+class FlatAffineValueConstraints;
+} // namespace affine
+
 namespace scf {
 class IfOp;
 
 /// Match "for loop"-like operations: If the first parameter is an iteration
 /// variable, return lower/upper bounds via the second/third parameter and the
 /// step size via the last parameter. The function should return `success` in
 /// that case. If the first parameter is not an iteration variable, return
 /// `failure`.
 using LoopMatcherFn = function_ref<LogicalResult(
     Value, OpFoldResult &, OpFoldResult &, OpFoldResult &)>;
 
 /// Match "for loop"-like operations from the SCF dialect.
 LogicalResult matchForLikeLoop(Value iv, OpFoldResult &lb, OpFoldResult &ub,
                                OpFoldResult &step);
 
 /// Populate the given constraint set with induction variable constraints of a
 /// "for" loop with the given range and step.
-LogicalResult addLoopRangeConstraints(FlatAffineValueConstraints &cstr,
+LogicalResult addLoopRangeConstraints(affine::FlatAffineValueConstraints &cstr,
                                       Value iv, OpFoldResult lb,
                                       OpFoldResult ub, OpFoldResult step);
 
 /// Try to canonicalize the given affine.min/max operation in the context of
 /// for `loops` with a known range.
 ///
 /// `loopMatcher` is used to retrieve loop bounds and the step size for a given
 /// iteration variable.

mlir/include/mlir/Dialect/SparseTensor/Transforms/Passes.td

func.func @kernel_matvec(%arga: tensor<?x?xf64, #SparseMatrix>,
           linalg.yield %1 : f64
       } -> tensor<?xf64>
       return %0 : tensor<?xf64>
     }
     ```
   }];
   let constructor = "mlir::createSparsificationPass()";
   let dependentDialects = [
-    "AffineDialect",
+    "affine::AffineDialect",
     "arith::ArithDialect",
     "bufferization::BufferizationDialect",
     "LLVM::LLVMDialect",
     "linalg::LinalgDialect",
     "memref::MemRefDialect",
     "scf::SCFDialect",
     "sparse_tensor::SparseTensorDialect",
   ];

mlir/include/mlir/Dialect/Tensor/IR/TensorBase.td

let description = [{
     The `tensor` type is actually a builtin type (it lives in the builtin
     dialect), and does not live in this dialect.
 
   }];
 
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
   let dependentDialects = [
-    "AffineDialect",
+    "affine::AffineDialect",
     "arith::ArithDialect",
     "complex::ComplexDialect",
   ];
 }
 
 #endif // TENSOR_BASE

mlir/include/mlir/Dialect/Tensor/Transforms/Passes.td

let description = [{
 
     At the moment, the following foldings occur when possible:
       - tensor.extract_slice into vector.transfer_read
       - vector.transfer_write into tensor.insert_slice
 
   }];
   let constructor = "mlir::tensor::createFoldTensorSubsetOpsPass()";
   let dependentDialects = [
-      "AffineDialect", "tensor::TensorDialect", "vector::VectorDialect"
+      "affine::AffineDialect", "tensor::TensorDialect", "vector::VectorDialect"
   ];
 }
 
 def TensorBufferize : Pass<"tensor-bufferize", "func::FuncOp"> {
   let summary = "Bufferize the `tensor` dialect";
   let constructor = "mlir::tensor::createTensorBufferizePass()";
 }
 
 #endif // MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES

mlir/include/mlir/Dialect/Vector/Utils/VectorUtils.h

 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/Support/LLVM.h"
 
 #include "llvm/ADT/DenseMap.h"
 
 namespace mlir {
 
 // Forward declarations.
-class AffineApplyOp;
-class AffineForOp;
 class AffineMap;
 class Block;
 class Location;
 class OpBuilder;
 class Operation;
 class ShapedType;
 class Value;
 class VectorType;
 class VectorTransferOpInterface;
 
+namespace affine {
+class AffineApplyOp;
+class AffineForOp;
+} // namespace affine
+
 namespace vector {
 /// Helper function that creates a memref::DimOp or tensor::DimOp depending on
 /// the type of `source`.
 Value createOrFoldDimOp(OpBuilder &b, Location loc, Value source, int64_t dim);
 } // namespace vector
 
 /// Constructs a permutation map of invariant memref indices to vector
 /// dimension.

mlir/include/mlir/InitAllDialects.h

 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 
 /// Add all the MLIR dialects to the provided registry.
 inline void registerAllDialects(DialectRegistry &registry) {
   // clang-format off
   registry.insert<acc::OpenACCDialect,
-                  AffineDialect,
+                  affine::AffineDialect,
                   arith::ArithDialect,
                   amdgpu::AMDGPUDialect,
                   amx::AMXDialect,
                   arm_neon::ArmNeonDialect,
                   async::AsyncDialect,
                   bufferization::BufferizationDialect,
                   cf::ControlFlowDialect,
                   complex::ComplexDialect,

mlir/include/mlir/InitAllPasses.h

 inline void registerAllPasses() {
   // General passes
   registerTransformsPasses();
 
   // Conversion passes
   registerConversionPasses();
 
   // Dialect passes
-  registerAffinePasses();
+  affine::registerAffinePasses();
   registerAsyncPasses();
   arith::registerArithPasses();
   bufferization::registerBufferizationPasses();
   func::registerFuncPasses();
   registerGPUPasses();
   registerGpuSerializeToCubinPass();
   registerGpuSerializeToHsacoPass();
   registerLinalgPasses();

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 #include "mlir/Transforms/Passes.h"
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTAFFINETOSTANDARD
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
+using namespace mlir::affine;
 using namespace mlir::vector;
 
 /// Given a range of values, emit the code that reduces them with "min" or "max"
 /// depending on the provided comparison predicate.  The predicate defines which
 /// comparison to perform, "lt" for "min", "gt" for "max" and is used for the
 /// `cmpi` operation followed by the `select` operation:
 ///
 ///   %cond   = arith.cmpi "predicate" %v0, %v1

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

struct ConvertLinalgToStandardPass
     : public impl::ConvertLinalgToStandardBase<ConvertLinalgToStandardPass> {
   void runOnOperation() override;
 };
 } // namespace
 
 void ConvertLinalgToStandardPass::runOnOperation() {
   auto module = getOperation();
   ConversionTarget target(getContext());
-  target.addLegalDialect<AffineDialect, arith::ArithDialect, func::FuncDialect,
-                         memref::MemRefDialect, scf::SCFDialect>();
+  target.addLegalDialect<affine::AffineDialect, arith::ArithDialect,
+                         func::FuncDialect, memref::MemRefDialect,
+                         scf::SCFDialect>();
   target.addLegalOp<ModuleOp, func::FuncOp, func::ReturnOp>();
   RewritePatternSet patterns(&getContext());
   populateLinalgToStandardConversionPatterns(patterns);
   if (failed(applyFullConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertLinalgToStandardPass() {
   return std::make_unique<ConvertLinalgToStandardPass>();
 }

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 #define DEBUG_TYPE "loops-to-gpu"
 
 using namespace mlir;
+using namespace mlir::affine;
 using namespace mlir::scf;
 
 // Name of internal attribute to mark visited operations during conversion.
 //
 // NOTE: The conversion originally used the following legality criteria:
 //   `!parallelOp->hasAttr(gpu::getMappingAttrName())`
 // But the provided pattern might reject some cases based on more detailed
 // analysis of the `mapping` attribute.

mlir/lib/Conversion/SCFToGPU/SCFToGPUPass.cpp

struct ForLoopMapper : public impl::ConvertAffineForToGPUBase<ForLoopMapper> {
   ForLoopMapper(unsigned numBlockDims, unsigned numThreadDims) {
     this->numBlockDims = numBlockDims;
     this->numThreadDims = numThreadDims;
   }
 
   void runOnOperation() override {
     for (Operation &op : llvm::make_early_inc_range(
              getOperation().getFunctionBody().getOps())) {
-      if (auto forOp = dyn_cast<AffineForOp>(&op)) {
+      if (auto forOp = dyn_cast<affine::AffineForOp>(&op)) {
         if (failed(convertAffineLoopNestToGPULaunch(forOp, numBlockDims,
                                                     numThreadDims)))
           signalPassFailure();
       }
     }
   }
 };
 

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

static void getXferIndices(RewriterBase &rewriter, TransferOpType xferOp,
   Location loc = xferOp.getLoc();
   unsigned offsetsIdx = 0;
   for (auto expr : xferOp.getPermutationMap().getResults()) {
     if (auto dim = expr.template dyn_cast<AffineDimExpr>()) {
       Value prevIdx = indices[dim.getPosition()];
       SmallVector<Value, 3> dims(dimValues.begin(), dimValues.end());
       dims.push_back(prevIdx);
       AffineExpr d0 = rewriter.getAffineDimExpr(offsetMap.getNumDims());
-      indices[dim.getPosition()] = makeComposedAffineApply(
+      indices[dim.getPosition()] = affine::makeComposedAffineApply(
           rewriter, loc, d0 + offsetMap.getResult(offsetsIdx++), dims);
       continue;
     }
   }
 }
 
 // Return true if the contract op can be convert to MMA matmul.
 static bool contractSupportsMMAMatrixType(vector::ContractionOp contract,

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

static void getXferIndices(OpBuilder &b, OpTy xferOp, Value iv,
   indices.append(prevIndices.begin(), prevIndices.end());
 
   Location loc = xferOp.getLoc();
   bool isBroadcast = !dim.has_value();
   if (!isBroadcast) {
     AffineExpr d0, d1;
     bindDims(xferOp.getContext(), d0, d1);
     Value offset = adaptor.getIndices()[*dim];
-    indices[*dim] = makeComposedAffineApply(b, loc, d0 + d1, {offset, iv});
+    indices[*dim] =
+        affine::makeComposedAffineApply(b, loc, d0 + d1, {offset, iv});
   }
 }
 
 static void maybeYieldValue(OpBuilder &b, Location loc, bool hasRetVal,
                             Value value) {
   if (hasRetVal) {
     assert(value && "Expected non-empty value");
     b.create<scf::YieldOp>(loc, value);
static Value generateInBoundsCheck(
   Location loc = xferOp.getLoc();
   ImplicitLocOpBuilder lb(xferOp.getLoc(), b);
   if (!xferOp.isDimInBounds(0) && !isBroadcast) {
     Value memrefDim =
         vector::createOrFoldDimOp(b, loc, xferOp.getSource(), *dim);
     AffineExpr d0, d1;
     bindDims(xferOp.getContext(), d0, d1);
     Value base = xferOp.getIndices()[*dim];
-    Value memrefIdx = makeComposedAffineApply(b, loc, d0 + d1, {base, iv});
+    Value memrefIdx =
+        affine::makeComposedAffineApply(b, loc, d0 + d1, {base, iv});
     cond = lb.create<arith::CmpIOp>(arith::CmpIPredicate::sgt, memrefDim,
                                     memrefIdx);
   }
 
   // Condition check 2: Masked in?
   if (auto maskCond = generateMaskCheck(b, xferOp, iv)) {
     if (cond)
       cond = lb.create<arith::AndIOp>(cond, maskCond);
get1dMemrefIndices(OpBuilder &b, OpTy xferOp, Value iv,
   assert(map.getNumResults() == 1 &&
          "Expected 1 permutation map result for 1D transfer");
   if (auto expr = map.getResult(0).template dyn_cast<AffineDimExpr>()) {
     Location loc = xferOp.getLoc();
     auto dim = expr.getPosition();
     AffineExpr d0, d1;
     bindDims(xferOp.getContext(), d0, d1);
     Value offset = memrefIndices[dim];
-    memrefIndices[dim] = makeComposedAffineApply(b, loc, d0 + d1, {offset, iv});
+    memrefIndices[dim] =
+        affine::makeComposedAffineApply(b, loc, d0 + d1, {offset, iv});
     return dim;
   }
 
   assert(xferOp.isBroadcastDim(0) &&
          "Expected AffineDimExpr or AffineConstantExpr");
   return std::nullopt;
 }
 

mlir/lib/Dialect/Affine/Analysis/AffineAnalysis.cpp

 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 #define DEBUG_TYPE "affine-analysis"
 
 using namespace mlir;
+using namespace affine;
 using namespace presburger;
 
 /// Get the value that is being reduced by `pos`-th reduction in the loop if
 /// such a reduction can be performed by affine parallel loops. This assumes
 /// floating-point operations are commutative. On success, `kind` will be the
 /// reduction kind suitable for use in affine parallel loop builder. If the
 /// reduction is not supported, returns null.
 static Value getSupportedReduction(AffineForOp forOp, unsigned pos,
static Value getSupportedReduction(AffineForOp forOp, unsigned pos,
   if (!maybeKind)
     return nullptr;
 
   kind = *maybeKind;
   return reducedVal;
 }
 
 /// Populate `supportedReductions` with descriptors of the supported reductions.
-void mlir::getSupportedReductions(
+void mlir::affine::getSupportedReductions(
     AffineForOp forOp, SmallVectorImpl<LoopReduction> &supportedReductions) {
   unsigned numIterArgs = forOp.getNumIterOperands();
   if (numIterArgs == 0)
     return;
   supportedReductions.reserve(numIterArgs);
   for (unsigned i = 0; i < numIterArgs; ++i) {
     arith::AtomicRMWKind kind;
     if (Value value = getSupportedReduction(forOp, i, kind))
       supportedReductions.emplace_back(LoopReduction{kind, i, value});
   }
 }
 
 /// Returns true if `forOp' is a parallel loop. If `parallelReductions` is
 /// provided, populates it with descriptors of the parallelizable reductions and
 /// treats them as not preventing parallelization.
-bool mlir::isLoopParallel(AffineForOp forOp,
-                          SmallVectorImpl<LoopReduction> *parallelReductions) {
+bool mlir::affine::isLoopParallel(
+    AffineForOp forOp, SmallVectorImpl<LoopReduction> *parallelReductions) {
   unsigned numIterArgs = forOp.getNumIterOperands();
 
   // Loop is not parallel if it has SSA loop-carried dependences and reduction
   // detection is not requested.
   if (numIterArgs > 0 && !parallelReductions)
     return false;
 
   // Find supported reductions of requested.
if (hasSingleEffect<MemoryEffects::Allocate>(defOp, v) &&
       enclosingOp->isProperAncestor(defOp))
     return true;
 
   // Aliasing ops.
   auto viewOp = dyn_cast<ViewLikeOpInterface>(defOp);
   return viewOp && isLocallyDefined(viewOp.getViewSource(), enclosingOp);
 }
 
-bool mlir::isLoopMemoryParallel(AffineForOp forOp) {
+bool mlir::affine::isLoopMemoryParallel(AffineForOp forOp) {
   // Any memref-typed iteration arguments are treated as serializing.
   if (llvm::any_of(forOp.getResultTypes(),
                    [](Type type) { return type.isa<BaseMemRefType>(); }))
     return false;
 
   // Collect all load and store ops in loop nest rooted at 'forOp'.
   SmallVector<Operation *, 8> loadAndStoreOps;
   auto walkResult = forOp.walk([&](Operation *op) -> WalkResult {
bool mlir::affine::isLoopMemoryParallel(AffineForOp forOp) {
   return true;
 }
 
 /// Returns the sequence of AffineApplyOp Operations operation in
 /// 'affineApplyOps', which are reachable via a search starting from 'operands',
 /// and ending at operands which are not defined by AffineApplyOps.
 // TODO: Add a method to AffineApplyOp which forward substitutes the
 // AffineApplyOp into any user AffineApplyOps.
-void mlir::getReachableAffineApplyOps(
+void mlir::affine::getReachableAffineApplyOps(
     ArrayRef<Value> operands, SmallVectorImpl<Operation *> &affineApplyOps) {
   struct State {
     // The ssa value for this node in the DFS traversal.
     Value value;
     // The operand index of 'value' to explore next during DFS traversal.
     unsigned operandIndex;
   };
   SmallVector<State, 4> worklist;

 // Builds a system of constraints with dimensional variables corresponding to
 // the loop IVs of the forOps appearing in that order. Any symbols founds in
 // the bound operands are added as symbols in the system. Returns failure for
 // the yet unimplemented cases.
 // TODO: Handle non-unit steps through local variables or stride information in
 // FlatAffineValueConstraints. (For eg., by using iv - lb % step = 0 and/or by
 // introducing a method in FlatAffineValueConstraints
 // setExprStride(ArrayRef<int64_t> expr, int64_t stride)
-LogicalResult mlir::getIndexSet(MutableArrayRef<Operation *> ops,
+LogicalResult mlir::affine::getIndexSet(MutableArrayRef<Operation *> ops,
                                         FlatAffineValueConstraints *domain) {
   SmallVector<Value, 4> indices;
   SmallVector<Operation *, 8> loopOps;
   size_t numDims = 0;
   for (Operation *op : ops) {
     if (!isa<AffineForOp, AffineIfOp, AffineParallelOp>(op)) {
       LLVM_DEBUG(llvm::dbgs() << "getIndexSet only handles affine.for/if/"
                                  "parallel ops");
       return failure();

 //       0        -1         0         0        0     0     0     50   >= 0
 //       0         0         1         0        0     0     0     0    >= 0
 //       0         0        -1         0        0     0     0     100  >= 0
 //       0         0         0         1        0     0     0     0    >= 0
 //       0         0         0        -1        0     0     0     50   >= 0
 //
 //
 // TODO: Support AffineExprs mod/floordiv/ceildiv.
-DependenceResult mlir::checkMemrefAccessDependence(
+DependenceResult mlir::affine::checkMemrefAccessDependence(
     const MemRefAccess &srcAccess, const MemRefAccess &dstAccess,
     unsigned loopDepth, FlatAffineValueConstraints *dependenceConstraints,
     SmallVector<DependenceComponent, 2> *dependenceComponents, bool allowRAR) {
   LLVM_DEBUG(llvm::dbgs() << "Checking for dependence at depth: "
                           << Twine(loopDepth) << " between:\n";);
   LLVM_DEBUG(srcAccess.opInst->dump());
   LLVM_DEBUG(dstAccess.opInst->dump());
 
DependenceResult mlir::affine::checkMemrefAccessDependence(
 
   if (dependenceConstraints)
     *dependenceConstraints = dstRel;
   return DependenceResult::HasDependence;
 }
 
 /// Gathers dependence components for dependences between all ops in loop nest
 /// rooted at 'forOp' at loop depths in range [1, maxLoopDepth].
-void mlir::getDependenceComponents(
+void mlir::affine::getDependenceComponents(
     AffineForOp forOp, unsigned maxLoopDepth,
     std::vector<SmallVector<DependenceComponent, 2>> *depCompsVec) {
   // Collect all load and store ops in loop nest rooted at 'forOp'.
   SmallVector<Operation *, 8> loadAndStoreOps;
   forOp->walk([&](Operation *op) {
     if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op))
       loadAndStoreOps.push_back(op);
   });

mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 #define DEBUG_TYPE "affine-structures"
 
 using namespace mlir;
+using namespace affine;
 using namespace presburger;
 
 
 void FlatAffineValueConstraints::addInductionVarOrTerminalSymbol(Value val) {
   if (containsVar(val))
     return;
 
   // Caller is expected to fully compose map/operands if necessary.
void FlatAffineRelation::removeVarRange(VarKind kind, unsigned varStart,
   unsigned intersectRangeRHS = std::max(varStart, getNumDomainDims());
 
   if (intersectDomainLHS > intersectDomainRHS)
     numDomainDims -= intersectDomainLHS - intersectDomainRHS;
   if (intersectRangeLHS > intersectRangeRHS)
     numRangeDims -= intersectRangeLHS - intersectRangeRHS;
 }
 
-LogicalResult mlir::getRelationFromMap(AffineMap &map,
+LogicalResult mlir::affine::getRelationFromMap(AffineMap &map,
                                                FlatAffineRelation &rel) {
   // Get flattened affine expressions.
   std::vector<SmallVector<int64_t, 8>> flatExprs;
   FlatAffineValueConstraints localVarCst;
   if (failed(getFlattenedAffineExprs(map, &flatExprs, &localVarCst)))
     return failure();
 
   unsigned oldDimNum = localVarCst.getNumDimVars();
   unsigned oldCols = localVarCst.getNumCols();
for (unsigned i = 0, e = map.getNumResults(); i < e; ++i) {
     localVarCst.addEquality(eq);
   }
 
   // Create relation and return success.
   rel = FlatAffineRelation(numDomainVars, numRangeVars, localVarCst);
   return success();
 }
 
-LogicalResult mlir::getRelationFromMap(const AffineValueMap &map,
+LogicalResult mlir::affine::getRelationFromMap(const AffineValueMap &map,
                                                FlatAffineRelation &rel) {
 
   AffineMap affineMap = map.getAffineMap();
   if (failed(getRelationFromMap(affineMap, rel)))
     return failure();
 
   // Set symbol values for domain dimensions and symbols.
   for (unsigned i = 0, e = rel.getNumDomainDims(); i < e; ++i)
     rel.setValue(i, map.getOperand(i));
   for (unsigned i = rel.getNumDimVars(), e = rel.getNumDimAndSymbolVars();
        i < e; ++i)
     rel.setValue(i, map.getOperand(i - rel.getNumRangeDims()));
 
   return success();
 }

mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include <numeric>
 #include <optional>
 #include <type_traits>
 
 using namespace mlir;
+using namespace mlir::affine;
 
 /// Returns the trip count of the loop as an affine expression if the latter is
 /// expressible as an affine expression, and nullptr otherwise. The trip count
 /// expression is simplified before returning. This method only utilizes map
 /// composition to construct lower and upper bounds before computing the trip
 /// count expressions.
-void mlir::getTripCountMapAndOperands(
+void mlir::affine::getTripCountMapAndOperands(
     AffineForOp forOp, AffineMap *tripCountMap,
     SmallVectorImpl<Value> *tripCountOperands) {
   MLIRContext *context = forOp.getContext();
   int64_t step = forOp.getStep();
   int64_t loopSpan;
   if (forOp.hasConstantBounds()) {
     int64_t lb = forOp.getConstantLowerBound();
     int64_t ub = forOp.getConstantUpperBound();
void mlir::affine::getTripCountMapAndOperands(
   tripCountOperands->assign(tripCountValueMap.getOperands().begin(),
                             tripCountValueMap.getOperands().end());
 }
 
 /// Returns the trip count of the loop if it's a constant, std::nullopt
 /// otherwise. This method uses affine expression analysis (in turn using
 /// getTripCount) and is able to determine constant trip count in non-trivial
 /// cases.
-std::optional<uint64_t> mlir::getConstantTripCount(AffineForOp forOp) {
+std::optional<uint64_t> mlir::affine::getConstantTripCount(AffineForOp forOp) {
   SmallVector<Value, 4> operands;
   AffineMap map;
   getTripCountMapAndOperands(forOp, &map, &operands);
 
   if (!map)
     return std::nullopt;
 
   // Take the min if all trip counts are constant.
if (auto constExpr = resultExpr.dyn_cast<AffineConstantExpr>()) {
       return std::nullopt;
   }
   return tripCount;
 }
 
 /// Returns the greatest known integral divisor of the trip count. Affine
 /// expression analysis is used (indirectly through getTripCount), and
 /// this method is thus able to determine non-trivial divisors.
-uint64_t mlir::getLargestDivisorOfTripCount(AffineForOp forOp) {
+uint64_t mlir::affine::getLargestDivisorOfTripCount(AffineForOp forOp) {
   SmallVector<Value, 4> operands;
   AffineMap map;
   getTripCountMapAndOperands(forOp, &map, &operands);
 
   if (!map)
     return 1;
 
   // The largest divisor of the trip count is the GCD of the individual largest
static bool isAccessIndexInvariant(Value iv, Value index) {
   }
 
   auto composeOp = cast<AffineApplyOp>(affineApplyOps[0]);
   // We need yet another level of indirection because the `dim` index of the
   // access may not correspond to the `dim` index of composeOp.
   return !composeOp.getAffineValueMap().isFunctionOf(0, iv);
 }
 
-DenseSet<Value> mlir::getInvariantAccesses(Value iv, ArrayRef<Value> indices) {
+DenseSet<Value> mlir::affine::getInvariantAccesses(Value iv,
+                                                   ArrayRef<Value> indices) {
   DenseSet<Value> res;
   for (auto val : indices) {
     if (isAccessIndexInvariant(iv, val)) {
       res.insert(val);
     }
   }
   return res;
 }
for (auto ls : loadAndStoresMatched) {
     }
     if (isVectorizableOp && !isVectorizableOp(loop, *op)) {
       return false;
     }
   }
   return true;
 }
 
-bool mlir::isVectorizableLoopBody(AffineForOp loop, int *memRefDim,
-                                  NestedPattern &vectorTransferMatcher) {
+bool mlir::affine::isVectorizableLoopBody(
+    AffineForOp loop, int *memRefDim, NestedPattern &vectorTransferMatcher) {
   *memRefDim = -1;
   VectorizableOpFun fun([memRefDim](AffineForOp loop, Operation &op) {
     auto load = dyn_cast<AffineLoadOp>(op);
     auto store = dyn_cast<AffineStoreOp>(op);
     int thisOpMemRefDim = -1;
     bool isContiguous = load ? isContiguousAccess(loop.getInductionVar(), load,
                                                   &thisOpMemRefDim)
                              : isContiguousAccess(loop.getInductionVar(), store,
                                                   &thisOpMemRefDim);
     if (thisOpMemRefDim != -1) {
       // If memory accesses vary across different dimensions then the loop is
       // not vectorizable.
       if (*memRefDim != -1 && *memRefDim != thisOpMemRefDim)
         return false;
       *memRefDim = thisOpMemRefDim;
     }
     return isContiguous;
   });
   return isVectorizableLoopBodyWithOpCond(loop, fun, vectorTransferMatcher);
 }
 
-bool mlir::isVectorizableLoopBody(AffineForOp loop,
-                                  NestedPattern &vectorTransferMatcher) {
+bool mlir::affine::isVectorizableLoopBody(
+    AffineForOp loop, NestedPattern &vectorTransferMatcher) {
   return isVectorizableLoopBodyWithOpCond(loop, nullptr, vectorTransferMatcher);
 }
 
 /// Checks whether SSA dominance would be violated if a for op's body
 /// operations are shifted by the specified shifts. This method checks if a
 /// 'def' and all its uses have the same shift factor.
 // TODO: extend this to check for memory-based dependence violation when we have
 // the support.
-bool mlir::isOpwiseShiftValid(AffineForOp forOp, ArrayRef<uint64_t> shifts) {
+bool mlir::affine::isOpwiseShiftValid(AffineForOp forOp,
+                                      ArrayRef<uint64_t> shifts) {
   auto *forBody = forOp.getBody();
   assert(shifts.size() == forBody->getOperations().size());
 
   // Work backwards over the body of the block so that the shift of a use's
   // ancestor operation in the block gets recorded before it's looked up.
   DenseMap<Operation *, uint64_t> forBodyShift;
   for (const auto &it :
        llvm::enumerate(llvm::reverse(forBody->getOperations()))) {

mlir/lib/Dialect/Affine/Analysis/NestedMatcher.cpp

 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 llvm::BumpPtrAllocator *&NestedMatch::allocator() {
   thread_local llvm::BumpPtrAllocator *allocator = nullptr;
   return allocator;
 }
 
 NestedMatch NestedMatch::build(Operation *operation,
                                ArrayRef<NestedMatch> nestedMatches) {
void NestedPattern::matchOne(Operation *op,
   }
 }
 
 static bool isAffineForOp(Operation &op) { return isa<AffineForOp>(op); }
 
 static bool isAffineIfOp(Operation &op) { return isa<AffineIfOp>(op); }
 
 namespace mlir {
+namespace affine {
 namespace matcher {
 
 NestedPattern Op(FilterFunctionType filter) {
   return NestedPattern({}, std::move(filter));
 }
 
 NestedPattern If(const NestedPattern &child) {
   return NestedPattern(child, isAffineIfOp);
return NestedPattern(
       nested, [=](Operation &op) { return isAffineForOp(op) && filter(op); });
 }
 
 bool isLoadOrStore(Operation &op) {
   return isa<AffineLoadOp, AffineStoreOp>(op);
 }
 
 } // namespace matcher
+} // namespace affine
 } // namespace mlir

mlir/lib/Dialect/Affine/Analysis/Utils.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 #define DEBUG_TYPE "analysis-utils"
 
 using namespace mlir;
+using namespace affine;
 using namespace presburger;
 
 using llvm::SmallDenseMap;
 
 using Node = MemRefDependenceGraph::Node;
 
 // LoopNestStateCollector walks loop nests and collects load and store
 // operations, and whether or not a region holding op other than ForOp and IfOp
for (const auto &idAndNode : nodes) {
     it = outEdges.find(idAndNode.first);
     if (it != outEdges.end()) {
       for (const auto &e : it->second)
         os << "  OutEdge: " << e.id << " " << e.value << "\n";
     }
   }
 }
 
-void mlir::getAffineForIVs(Operation &op, SmallVectorImpl<AffineForOp> *loops) {
+void mlir::affine::getAffineForIVs(Operation &op,
+                                   SmallVectorImpl<AffineForOp> *loops) {
   auto *currOp = op.getParentOp();
   AffineForOp currAffineForOp;
   // Traverse up the hierarchy collecting all 'affine.for' operation while
   // skipping over 'affine.if' operations.
   while (currOp) {
     if (AffineForOp currAffineForOp = dyn_cast<AffineForOp>(currOp))
       loops->push_back(currAffineForOp);
     currOp = currOp->getParentOp();
   }
   std::reverse(loops->begin(), loops->end());
 }
 
-void mlir::getEnclosingAffineOps(Operation &op,
+void mlir::affine::getEnclosingAffineOps(Operation &op,
                                          SmallVectorImpl<Operation *> *ops) {
   ops->clear();
   Operation *currOp = op.getParentOp();
 
   // Traverse up the hierarchy collecting all `affine.for`, `affine.if`, and
   // affine.parallel operations.
   while (currOp) {
     if (isa<AffineIfOp, AffineForOp, AffineParallelOp>(currOp))
       ops->push_back(currOp);
LogicalResult MemRefRegion::compute(Operation *op, unsigned loopDepth,
   cst.removeTrivialRedundancy();
 
   LLVM_DEBUG(llvm::dbgs() << "Memory region:\n");
   LLVM_DEBUG(cst.dump());
   return success();
 }
 
 std::optional<int64_t>
-mlir::getMemRefIntOrFloatEltSizeInBytes(MemRefType memRefType) {
+mlir::affine::getMemRefIntOrFloatEltSizeInBytes(MemRefType memRefType) {
   auto elementType = memRefType.getElementType();
 
   unsigned sizeInBits;
   if (elementType.isIntOrFloat()) {
     sizeInBits = elementType.getIntOrFloatBitWidth();
   } else if (auto vectorType = elementType.dyn_cast<VectorType>()) {
     if (vectorType.getElementType().isIntOrFloat())
       sizeInBits =
std::optional<int64_t> MemRefRegion::getRegionSize() {
   return *eltSize * *numElements;
 }
 
 /// Returns the size of memref data in bytes if it's statically shaped,
 /// std::nullopt otherwise.  If the element of the memref has vector type, takes
 /// into account size of the vector as well.
 //  TODO: improve/complete this when we have target data.
 std::optional<uint64_t>
-mlir::getIntOrFloatMemRefSizeInBytes(MemRefType memRefType) {
+mlir::affine::getIntOrFloatMemRefSizeInBytes(MemRefType memRefType) {
   if (!memRefType.hasStaticShape())
     return std::nullopt;
   auto elementType = memRefType.getElementType();
   if (!elementType.isIntOrFloat() && !elementType.isa<VectorType>())
     return std::nullopt;
 
   auto sizeInBytes = getMemRefIntOrFloatEltSizeInBytes(memRefType);
   if (!sizeInBytes)
     return std::nullopt;
   for (unsigned i = 0, e = memRefType.getRank(); i < e; i++) {
     sizeInBytes = *sizeInBytes * memRefType.getDimSize(i);
   }
   return sizeInBytes;
 }
 
 template <typename LoadOrStoreOp>
-LogicalResult mlir::boundCheckLoadOrStoreOp(LoadOrStoreOp loadOrStoreOp,
+LogicalResult mlir::affine::boundCheckLoadOrStoreOp(LoadOrStoreOp loadOrStoreOp,
                                                     bool emitError) {
   static_assert(llvm::is_one_of<LoadOrStoreOp, AffineReadOpInterface,
                                 AffineWriteOpInterface>::value,
                 "argument should be either a AffineReadOpInterface or a "
                 "AffineWriteOpInterface");
 
   Operation *op = loadOrStoreOp.getOperation();
   MemRefRegion region(op->getLoc());
   if (failed(region.compute(op, /*loopDepth=*/0, /*sliceState=*/nullptr,
if (outOfBounds && emitError) {
           << "memref out of lower bound access along dimension #" << (r + 1);
     }
   }
   return failure(outOfBounds);
 }
 
 // Explicitly instantiate the template so that the compiler knows we need them!
 template LogicalResult
-mlir::boundCheckLoadOrStoreOp(AffineReadOpInterface loadOp, bool emitError);
+mlir::affine::boundCheckLoadOrStoreOp(AffineReadOpInterface loadOp,
+                                      bool emitError);
 template LogicalResult
-mlir::boundCheckLoadOrStoreOp(AffineWriteOpInterface storeOp, bool emitError);
+mlir::affine::boundCheckLoadOrStoreOp(AffineWriteOpInterface storeOp,
+                                      bool emitError);
 
 // Returns in 'positions' the Block positions of 'op' in each ancestor
 // Block from the Block containing operation, stopping at 'limitBlock'.
 static void findInstPosition(Operation *op, Block *limitBlock,
                              SmallVectorImpl<unsigned> *positions) {
   Block *block = op->getBlock();
   while (block != limitBlock) {
     // FIXME: This algorithm is unnecessarily O(n) and should be improved to not
if (ivs.count(value) == 0) {
         return failure();
     }
   }
   return success();
 }
 
 /// Returns the innermost common loop depth for the set of operations in 'ops'.
 // TODO: Move this to LoopUtils.
-unsigned mlir::getInnermostCommonLoopDepth(
+unsigned mlir::affine::getInnermostCommonLoopDepth(
     ArrayRef<Operation *> ops, SmallVectorImpl<AffineForOp> *surroundingLoops) {
   unsigned numOps = ops.size();
   assert(numOps > 0 && "Expected at least one operation");
 
   std::vector<SmallVector<AffineForOp, 4>> loops(numOps);
   unsigned loopDepthLimit = std::numeric_limits<unsigned>::max();
   for (unsigned i = 0; i < numOps; ++i) {
     getAffineForIVs(*ops[i], &loops[i]);
unsigned mlir::affine::getInnermostCommonLoopDepth(
   return loopDepth;
 }
 
 /// Computes in 'sliceUnion' the union of all slice bounds computed at
 /// 'loopDepth' between all dependent pairs of ops in 'opsA' and 'opsB', and
 /// then verifies if it is valid. Returns 'SliceComputationResult::Success' if
 /// union was computed correctly, an appropriate failure otherwise.
 SliceComputationResult
-mlir::computeSliceUnion(ArrayRef<Operation *> opsA, ArrayRef<Operation *> opsB,
-                        unsigned loopDepth, unsigned numCommonLoops,
-                        bool isBackwardSlice,
+mlir::affine::computeSliceUnion(ArrayRef<Operation *> opsA,
+                                ArrayRef<Operation *> opsB, unsigned loopDepth,
+                                unsigned numCommonLoops, bool isBackwardSlice,
                                 ComputationSliceState *sliceUnion) {
   // Compute the union of slice bounds between all pairs in 'opsA' and
   // 'opsB' in 'sliceUnionCst'.
   FlatAffineValueConstraints sliceUnionCst;
   assert(sliceUnionCst.getNumDimAndSymbolVars() == 0);
   std::vector<std::pair<Operation *, Operation *>> dependentOpPairs;
   for (auto *i : opsA) {
     MemRefAccess srcAccess(i);
     for (auto *j : opsB) {
for (auto *j : opsB) {
         return SliceComputationResult::GenericFailure;
       }
       if (result.value == DependenceResult::NoDependence)
         continue;
       dependentOpPairs.emplace_back(i, j);
 
       // Compute slice bounds for 'srcAccess' and 'dstAccess'.
       ComputationSliceState tmpSliceState;
-      mlir::getComputationSliceState(i, j, &dependenceConstraints, loopDepth,
-                                     isBackwardSlice, &tmpSliceState);
+      mlir::affine::getComputationSliceState(i, j, &dependenceConstraints,
+                                             loopDepth, isBackwardSlice,
+                                             &tmpSliceState);
 
       if (sliceUnionCst.getNumDimAndSymbolVars() == 0) {
         // Initialize 'sliceUnionCst' with the bounds computed in previous step.
         if (failed(tmpSliceState.getAsConstraints(&sliceUnionCst))) {
           LLVM_DEBUG(llvm::dbgs()
                      << "Unable to compute slice bound constraints\n");
           return SliceComputationResult::GenericFailure;
         }
if (!cExpr)
     return std::nullopt;
   return cExpr.getValue();
 }
 
 // Builds a map 'tripCountMap' from AffineForOp to constant trip count for loop
 // nest surrounding represented by slice loop bounds in 'slice'. Returns true
 // on success, false otherwise (if a non-constant trip count was encountered).
 // TODO: Make this work with non-unit step loops.
-bool mlir::buildSliceTripCountMap(
+bool mlir::affine::buildSliceTripCountMap(
     const ComputationSliceState &slice,
     llvm::SmallDenseMap<Operation *, uint64_t, 8> *tripCountMap) {
   unsigned numSrcLoopIVs = slice.ivs.size();
   // Populate map from AffineForOp -> trip count
   for (unsigned i = 0; i < numSrcLoopIVs; ++i) {
     AffineForOp forOp = getForInductionVarOwner(slice.ivs[i]);
     auto *op = forOp.getOperation();
     AffineMap lbMap = slice.lbs[i];
for (unsigned i = 0; i < numSrcLoopIVs; ++i) {
     if (!tripCount.has_value())
       return false;
     (*tripCountMap)[op] = *tripCount;
   }
   return true;
 }
 
 // Return the number of iterations in the given slice.
-uint64_t mlir::getSliceIterationCount(
+uint64_t mlir::affine::getSliceIterationCount(
     const llvm::SmallDenseMap<Operation *, uint64_t, 8> &sliceTripCountMap) {
   uint64_t iterCount = 1;
   for (const auto &count : sliceTripCountMap) {
     iterCount *= count.second;
   }
   return iterCount;
 }
 
 const char *const kSliceFusionBarrierAttrName = "slice_fusion_barrier";
 // Computes slice bounds by projecting out any loop IVs from
 // 'dependenceConstraints' at depth greater than 'loopDepth', and computes slice
 // bounds in 'sliceState' which represent the one loop nest's IVs in terms of
 // the other loop nest's IVs, symbols and constants (using 'isBackwardsSlice').
-void mlir::getComputationSliceState(
+void mlir::affine::getComputationSliceState(
     Operation *depSourceOp, Operation *depSinkOp,
     FlatAffineValueConstraints *dependenceConstraints, unsigned loopDepth,
     bool isBackwardSlice, ComputationSliceState *sliceState) {
   // Get loop nest surrounding src operation.
   SmallVector<AffineForOp, 4> srcLoopIVs;
   getAffineForIVs(*depSourceOp, &srcLoopIVs);
   unsigned numSrcLoopIVs = srcLoopIVs.size();
 

 // TODO: extend the slicing utility to compute slices that
 // aren't necessarily a one-to-one relation b/w the source and destination. The
 // relation between the source and destination could be many-to-many in general.
 // TODO: the slice computation is incorrect in the cases
 // where the dependence from the source to the destination does not cover the
 // entire destination index set. Subtract out the dependent destination
 // iterations from destination index set and check for emptiness --- this is one
 // solution.
-AffineForOp
-mlir::insertBackwardComputationSlice(Operation *srcOpInst, Operation *dstOpInst,
-                                     unsigned dstLoopDepth,
-                                     ComputationSliceState *sliceState) {
+AffineForOp mlir::affine::insertBackwardComputationSlice(
+    Operation *srcOpInst, Operation *dstOpInst, unsigned dstLoopDepth,
   // Get loop nest surrounding src operation.
   SmallVector<AffineForOp, 4> srcLoopIVs;
   getAffineForIVs(*srcOpInst, &srcLoopIVs);
   unsigned numSrcLoopIVs = srcLoopIVs.size();
 
   // Get loop nest surrounding dst operation.
   SmallVector<AffineForOp, 4> dstLoopIVs;
   getAffineForIVs(*dstOpInst, &dstLoopIVs);

 }
 
 bool MemRefAccess::isStore() const {
   return isa<AffineWriteOpInterface>(opInst);
 }
 
 /// Returns the nesting depth of this statement, i.e., the number of loops
 /// surrounding this statement.
-unsigned mlir::getNestingDepth(Operation *op) {
+unsigned mlir::affine::getNestingDepth(Operation *op) {
   Operation *currOp = op;
   unsigned depth = 0;
   while ((currOp = currOp->getParentOp())) {
     if (isa<AffineForOp>(currOp))
       depth++;
   }
   return depth;
 }
bool MemRefAccess::operator==(const MemRefAccess &rhs) const {
   AffineValueMap diff, thisMap, rhsMap;
   getAccessMap(&thisMap);
   rhs.getAccessMap(&rhsMap);
   AffineValueMap::difference(thisMap, rhsMap, &diff);
   return llvm::all_of(diff.getAffineMap().getResults(),
                       [](AffineExpr e) { return e == 0; });
 }
 
-void mlir::getAffineIVs(Operation &op, SmallVectorImpl<Value> &ivs) {
+void mlir::affine::getAffineIVs(Operation &op, SmallVectorImpl<Value> &ivs) {
   auto *currOp = op.getParentOp();
   AffineForOp currAffineForOp;
   // Traverse up the hierarchy collecting all 'affine.for' and affine.parallel
   // operation while skipping over 'affine.if' operations.
   while (currOp) {
     if (AffineForOp currAffineForOp = dyn_cast<AffineForOp>(currOp))
       ivs.push_back(currAffineForOp.getInductionVar());
     else if (auto parOp = dyn_cast<AffineParallelOp>(currOp))
       llvm::append_range(ivs, parOp.getIVs());
     currOp = currOp->getParentOp();
   }
   std::reverse(ivs.begin(), ivs.end());
 }
 
 /// Returns the number of surrounding loops common to 'loopsA' and 'loopsB',
 /// where each lists loops from outer-most to inner-most in loop nest.
-unsigned mlir::getNumCommonSurroundingLoops(Operation &a, Operation &b) {
+unsigned mlir::affine::getNumCommonSurroundingLoops(Operation &a,
+                                                    Operation &b) {
   SmallVector<Value, 4> loopsA, loopsB;
   getAffineIVs(a, loopsA);
   getAffineIVs(b, loopsB);
 
   unsigned minNumLoops = std::min(loopsA.size(), loopsB.size());
   unsigned numCommonLoops = 0;
   for (unsigned i = 0; i < minNumLoops; ++i) {
     if (loopsA[i] != loopsB[i])
for (const auto &region : regions) {
     std::optional<int64_t> size = region.second->getRegionSize();
     if (!size.has_value())
       return std::nullopt;
     totalSizeInBytes += *size;
   }
   return totalSizeInBytes;
 }
 
-std::optional<int64_t> mlir::getMemoryFootprintBytes(AffineForOp forOp,
+std::optional<int64_t> mlir::affine::getMemoryFootprintBytes(AffineForOp forOp,
                                                              int memorySpace) {
   auto *forInst = forOp.getOperation();
   return ::getMemoryFootprintBytes(
       *forInst->getBlock(), Block::iterator(forInst),
       std::next(Block::iterator(forInst)), memorySpace);
 }
 
 /// Returns whether a loop is parallel and contains a reduction loop.
-bool mlir::isLoopParallelAndContainsReduction(AffineForOp forOp) {
+bool mlir::affine::isLoopParallelAndContainsReduction(AffineForOp forOp) {
   SmallVector<LoopReduction> reductions;
   if (!isLoopParallel(forOp, &reductions))
     return false;
   return !reductions.empty();
 }
 
 /// Returns in 'sequentialLoops' all sequential loops in loop nest rooted
 /// at 'forOp'.
-void mlir::getSequentialLoops(AffineForOp forOp,
-                              llvm::SmallDenseSet<Value, 8> *sequentialLoops) {
+void mlir::affine::getSequentialLoops(
+    AffineForOp forOp, llvm::SmallDenseSet<Value, 8> *sequentialLoops) {
   forOp->walk([&](Operation *op) {
     if (auto innerFor = dyn_cast<AffineForOp>(op))
       if (!isLoopParallel(innerFor))
         sequentialLoops->insert(innerFor.getInductionVar());
   });
 }
 
-IntegerSet mlir::simplifyIntegerSet(IntegerSet set) {
+IntegerSet mlir::affine::simplifyIntegerSet(IntegerSet set) {
   FlatAffineValueConstraints fac(set);
   if (fac.isEmpty())
     return IntegerSet::getEmptySet(set.getNumDims(), set.getNumSymbols(),
                                    set.getContext());
   fac.removeTrivialRedundancy();
 
   auto simplifiedSet = fac.getAsIntegerSet(set.getContext());
   assert(simplifiedSet && "guaranteed to succeed while roundtripping");

 //   (set `opBound` to `op` upper bound in terms of `invar` and "extra syms")
 //    ... |     0 |      -1 |   0 |           ... |   ... |               = 0
 //  ------+-------+---------+-----+---------------+-------+-------------------
 //   (for each `op` map result r_i: set r_i to corresponding map result,
 //    prove that r_i >= minOpUb via contradiction)
 //    ... |     0 |       0 |  -1 |           ... |   ... |               = 0
 //      0 |     0 |       1 |  -1 |             0 |    -1 |              >= 0
 //
-FailureOr<AffineValueMap>
-mlir::simplifyConstrainedMinMaxOp(Operation *op,
-                                  FlatAffineValueConstraints constraints) {
+FailureOr<AffineValueMap> mlir::affine::simplifyConstrainedMinMaxOp(
+    Operation *op, FlatAffineValueConstraints constraints) {
   bool isMin = isa<AffineMinOp>(op);
   assert((isMin || isa<AffineMaxOp>(op)) && "expect AffineMin/MaxOp");
   MLIRContext *ctx = op->getContext();
   Builder builder(ctx);
   AffineMap map =
       isMin ? cast<AffineMinOp>(op).getMap() : cast<AffineMaxOp>(op).getMap();
   ValueRange operands = op->getOperands();
   unsigned numResults = map.getNumResults();
if (auto bound = constraints.getConstantBound64(BoundType::EQ, i)) {
       AffineExpr expr =
           i < newMap.getNumDims()
               ? builder.getAffineDimExpr(i)
               : builder.getAffineSymbolExpr(i - newMap.getNumDims());
       newMap = newMap.replace(expr, builder.getAffineConstantExpr(*bound),
                               newMap.getNumDims(), newMap.getNumSymbols());
     }
   }
-  mlir::canonicalizeMapAndOperands(&newMap, &newOperands);
+  affine::canonicalizeMapAndOperands(&newMap, &newOperands);
   return AffineValueMap(newMap, newOperands);
 }

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include <numeric>
 #include <optional>
 
 using namespace mlir;
+using namespace mlir::affine;
 
 #define DEBUG_TYPE "affine-ops"
 
 #include "mlir/Dialect/Affine/IR/AffineOpsDialect.cpp.inc"
 
 /// A utility function to check if a value is defined at the top level of
 /// `region` or is an argument of `region`. A value of index type defined at the
 /// top level of a `AffineScope` region is always a valid symbol for all
 /// uses in that region.
-bool mlir::isTopLevelValue(Value value, Region *region) {
+bool mlir::affine::isTopLevelValue(Value value, Region *region) {
   if (auto arg = value.dyn_cast<BlockArgument>())
     return arg.getParentRegion() == region;
   return value.getDefiningOp()->getParentRegion() == region;
 }
 
 /// Checks if `value` known to be a legal affine dimension or symbol in `src`
 /// region remains legal if the operation that uses it is inlined into `dest`
 /// with the given value mapping. `legalityCheck` is either `isValidDim` or
Operation *AffineDialect::materializeConstant(OpBuilder &builder,
                                               Location loc) {
   return builder.create<arith::ConstantOp>(loc, type, value);
 }
 
 /// A utility function to check if a value is defined at the top level of an
 /// op with trait `AffineScope`. If the value is defined in an unlinked region,
 /// conservatively assume it is not top-level. A value of index type defined at
 /// the top level is always a valid symbol.
-bool mlir::isTopLevelValue(Value value) {
+bool mlir::affine::isTopLevelValue(Value value) {
   if (auto arg = value.dyn_cast<BlockArgument>()) {
     // The block owning the argument may be unlinked, e.g. when the surrounding
     // region has not yet been attached to an Op, at which point the parent Op
     // is null.
     Operation *parentOp = arg.getOwner()->getParentOp();
     return parentOp && parentOp->hasTrait<OpTrait::AffineScope>();
   }
   // The defining Op may live in an unlinked block so its parent Op may be null.
   Operation *parentOp = value.getDefiningOp()->getParentOp();
   return parentOp && parentOp->hasTrait<OpTrait::AffineScope>();
 }
 
 /// Returns the closest region enclosing `op` that is held by an operation with
 /// trait `AffineScope`; `nullptr` if there is no such region.
-Region *mlir::getAffineScope(Operation *op) {
+Region *mlir::affine::getAffineScope(Operation *op) {
   auto *curOp = op;
   while (auto *parentOp = curOp->getParentOp()) {
     if (parentOp->hasTrait<OpTrait::AffineScope>())
       return curOp->getParentRegion();
     curOp = parentOp;
   }
   return nullptr;
 }
 
 // A Value can be used as a dimension id iff it meets one of the following
 // conditions:
 // *) It is valid as a symbol.
 // *) It is an induction variable.
 // *) It is the result of affine apply operation with dimension id arguments.
-bool mlir::isValidDim(Value value) {
+bool mlir::affine::isValidDim(Value value) {
   // The value must be an index type.
   if (!value.getType().isIndex())
     return false;
 
   if (auto *defOp = value.getDefiningOp())
     return isValidDim(value, getAffineScope(defOp));
 
   // This value has to be a block argument for an op that has the
   // `AffineScope` trait or for an affine.for or affine.parallel.
   auto *parentOp = value.cast<BlockArgument>().getOwner()->getParentOp();
   return parentOp && (parentOp->hasTrait<OpTrait::AffineScope>() ||
                       isa<AffineForOp, AffineParallelOp>(parentOp));
 }
 
 // Value can be used as a dimension id iff it meets one of the following
 // conditions:
 // *) It is valid as a symbol.
 // *) It is an induction variable.
 // *) It is the result of an affine apply operation with dimension id operands.
-bool mlir::isValidDim(Value value, Region *region) {
+bool mlir::affine::isValidDim(Value value, Region *region) {
   // The value must be an index type.
   if (!value.getType().isIndex())
     return false;
 
   // All valid symbols are okay.
   if (isValidSymbol(value, region))
     return true;
 

 // A value can be used as a symbol (at all its use sites) iff it meets one of
 // the following conditions:
 // *) It is a constant.
 // *) Its defining op or block arg appearance is immediately enclosed by an op
 //    with `AffineScope` trait.
 // *) It is the result of an affine.apply operation with symbol operands.
 // *) It is a result of the dim op on a memref whose corresponding size is a
 //    valid symbol.
-bool mlir::isValidSymbol(Value value) {
+bool mlir::affine::isValidSymbol(Value value) {
   if (!value)
     return false;
 
   // The value must be an index type.
   if (!value.getType().isIndex())
     return false;
 
   // Check that the value is a top level value.

 /// *) It is the result of an affine apply operation with symbol arguments.
 /// *) It is a result of the dim op on a memref whose corresponding size is
 ///    a valid symbol.
 /// *) It is defined at the top level of 'region' or is its argument.
 /// *) It dominates `region`'s parent op.
 /// If `region` is null, conservatively assume the symbol definition scope does
 /// not exist and only accept the values that would be symbols regardless of
 /// the surrounding region structure, i.e. the first three cases above.
-bool mlir::isValidSymbol(Value value, Region *region) {
+bool mlir::affine::isValidSymbol(Value value, Region *region) {
   // The value must be an index type.
   if (!value.getType().isIndex())
     return false;
 
   // A top-level value is a valid symbol.
   if (region && ::isTopLevelValue(value, region))
     return true;
 
static void printDimAndSymbolList(Operation::operand_iterator begin,
                                   unsigned numDims, OpAsmPrinter &printer) {
   OperandRange operands(begin, end);
   printer << '(' << operands.take_front(numDims) << ')';
   if (operands.size() > numDims)
     printer << '[' << operands.drop_front(numDims) << ']';
 }
 
 /// Parses dimension and symbol list and returns true if parsing failed.
-ParseResult mlir::parseDimAndSymbolList(OpAsmParser &parser,
-                                        SmallVectorImpl<Value> &operands,
-                                        unsigned &numDims) {
+ParseResult mlir::affine::parseDimAndSymbolList(
+    OpAsmParser &parser, SmallVectorImpl<Value> &operands, unsigned &numDims) {
   SmallVector<OpAsmParser::UnresolvedOperand, 8> opInfos;
   if (parser.parseOperandList(opInfos, OpAsmParser::Delimiter::Paren))
     return failure();
   // Store number of dimensions for validation by caller.
   numDims = opInfos.size();
 
   // Parse the optional symbol operands.
   auto indexTy = parser.getBuilder().getIndexType();
LogicalResult AffineApplyOp::verify() {
 
   return success();
 }
 
 // The result of the affine apply operation can be used as a dimension id if all
 // its operands are valid dimension ids.
 bool AffineApplyOp::isValidDim() {
   return llvm::all_of(getOperands(),
-                      [](Value op) { return mlir::isValidDim(op); });
+                      [](Value op) { return affine::isValidDim(op); });
 }
 
 // The result of the affine apply operation can be used as a dimension id if all
 // its operands are valid dimension ids with the parent operation of `region`
 // defining the polyhedral scope for symbols.
 bool AffineApplyOp::isValidDim(Region *region) {
   return llvm::all_of(getOperands(),
                       [&](Value op) { return ::isValidDim(op, region); });
 }
 
 // The result of the affine apply operation can be used as a symbol if all its
 // operands are symbols.
 bool AffineApplyOp::isValidSymbol() {
   return llvm::all_of(getOperands(),
-                      [](Value op) { return mlir::isValidSymbol(op); });
+                      [](Value op) { return affine::isValidSymbol(op); });
 }
 
 // The result of the affine apply operation can be used as a symbol in `region`
 // if all its operands are symbols in `region`.
 bool AffineApplyOp::isValidSymbol(Region *region) {
   return llvm::all_of(getOperands(), [&](Value operand) {
-    return mlir::isValidSymbol(operand, region);
+    return affine::isValidSymbol(operand, region);
   });
 }
 
 OpFoldResult AffineApplyOp::fold(FoldAdaptor adaptor) {
   auto map = getAffineMap();
 
   // Fold dims and symbols to existing values.
   auto expr = map.getResult(0);
static void composeAffineMapAndOperands(AffineMap *map,
   *map = map->replaceDimsAndSymbols(dimReplacements, symReplacements, nDims,
                                     nSyms);
 
   // Canonicalize and simplify before returning.
   canonicalizeMapAndOperands(map, operands);
   *map = simplifyAffineMap(*map);
 }
 
-void mlir::fullyComposeAffineMapAndOperands(AffineMap *map,
-                                            SmallVectorImpl<Value> *operands) {
+void mlir::affine::fullyComposeAffineMapAndOperands(
+    AffineMap *map, SmallVectorImpl<Value> *operands) {
   while (llvm::any_of(*operands, [](Value v) {
     return isa_and_nonnull<AffineApplyOp>(v.getDefiningOp());
   })) {
     composeAffineMapAndOperands(map, operands);
   }
 }
 
 /// Given a list of `OpFoldResult`, build the necessary operations to populate
createOrFold(OpBuilder &b, Location loc, ValueRange operands,
 
   // Notify the listener now that we definitely know that the operation will
   // persist. Use the original listener stored in the variable.
   if (listener)
     listener->notifyOperationInserted(op);
   return op->getResult(0);
 }
 
-AffineApplyOp mlir::makeComposedAffineApply(OpBuilder &b, Location loc,
+AffineApplyOp mlir::affine::makeComposedAffineApply(OpBuilder &b, Location loc,
                                                     AffineMap map,
                                                     ValueRange operands) {
   AffineMap normalizedMap = map;
   SmallVector<Value, 8> normalizedOperands(operands.begin(), operands.end());
   composeAffineMapAndOperands(&normalizedMap, &normalizedOperands);
   assert(normalizedMap);
   return b.create<AffineApplyOp>(loc, normalizedMap, normalizedOperands);
 }
 
-AffineApplyOp mlir::makeComposedAffineApply(OpBuilder &b, Location loc,
-                                            AffineExpr e, ValueRange values) {
+AffineApplyOp mlir::affine::makeComposedAffineApply(OpBuilder &b, Location loc,
+                                                    AffineExpr e,
+                                                    ValueRange values) {
   return makeComposedAffineApply(
       b, loc, AffineMap::inferFromExprList(ArrayRef<AffineExpr>{e}).front(),
       values);
 }
 
 /// Composes the given affine map with the given list of operands, pulling in
 /// the maps from any affine.apply operations that supply the operands.
 static void composeMultiResultAffineMap(AffineMap &map,
static void composeMultiResultAffineMap(AffineMap &map,
   // Canonicalize the map created from composed expressions to deduplicate the
   // dimension and symbol operands.
   operands = llvm::to_vector(llvm::concat<Value>(dims, symbols));
   map = AffineMap::get(dims.size(), symbols.size(), exprs, map.getContext());
   canonicalizeMapAndOperands(&map, &operands);
 }
 
 OpFoldResult
-mlir::makeComposedFoldedAffineApply(OpBuilder &b, Location loc, AffineMap map,
+mlir::affine::makeComposedFoldedAffineApply(OpBuilder &b, Location loc,
+                                            AffineMap map,
                                             ArrayRef<OpFoldResult> operands) {
   assert(map.getNumResults() == 1 && "building affine.apply with !=1 result");
 
   SmallVector<Operation *> constants;
   SmallVector<Value> actualValues;
   materializeConstants(b, loc, operands, constants, actualValues);
   composeAffineMapAndOperands(&map, &actualValues);
   OpFoldResult result = createOrFold<AffineApplyOp>(b, loc, actualValues, map);
 
   // Constants are always folded into affine min/max because they can be
   // represented as constant expressions, so delete them.
   for (Operation *op : constants)
     op->erase();
   return result;
 }
 
 OpFoldResult
-mlir::makeComposedFoldedAffineApply(OpBuilder &b, Location loc, AffineExpr expr,
+mlir::affine::makeComposedFoldedAffineApply(OpBuilder &b, Location loc,
+                                            AffineExpr expr,
                                             ArrayRef<OpFoldResult> operands) {
   return makeComposedFoldedAffineApply(
       b, loc, AffineMap::inferFromExprList(ArrayRef<AffineExpr>{expr}).front(),
       operands);
 }
 
-SmallVector<OpFoldResult> mlir::makeComposedFoldedMultiResultAffineApply(
+SmallVector<OpFoldResult>
+mlir::affine::makeComposedFoldedMultiResultAffineApply(
     OpBuilder &b, Location loc, AffineMap map,
     ArrayRef<OpFoldResult> operands) {
   return llvm::to_vector(llvm::map_range(
       llvm::seq<unsigned>(0, map.getNumResults()), [&](unsigned i) {
         return makeComposedFoldedAffineApply(b, loc, map.getSubMap({i}),
                                              operands);
       }));
 }
 
-Value mlir::makeComposedAffineMin(OpBuilder &b, Location loc, AffineMap map,
-                                  ValueRange operands) {
+Value mlir::affine::makeComposedAffineMin(OpBuilder &b, Location loc,
+                                          AffineMap map, ValueRange operands) {
   SmallVector<Value> allOperands = llvm::to_vector(operands);
   composeMultiResultAffineMap(map, allOperands);
   return b.createOrFold<AffineMinOp>(loc, b.getIndexType(), map, allOperands);
 }
 
 template <typename OpTy>
 static OpFoldResult makeComposedFoldedMinMax(OpBuilder &b, Location loc,
                                              AffineMap map,
                                              ArrayRef<OpFoldResult> operands) {
   SmallVector<Operation *> constants;
   SmallVector<Value> actualValues;
   materializeConstants(b, loc, operands, constants, actualValues);
   composeMultiResultAffineMap(map, actualValues);
   OpFoldResult result =
       createOrFold<OpTy>(b, loc, actualValues, b.getIndexType(), map);
 
   // Constants are always folded into affine min/max because they can be
   // represented as constant expressions, so delete them.
   for (Operation *op : constants)
     op->erase();
   return result;
 }
 
 OpFoldResult
-mlir::makeComposedFoldedAffineMin(OpBuilder &b, Location loc, AffineMap map,
+mlir::affine::makeComposedFoldedAffineMin(OpBuilder &b, Location loc,
+                                          AffineMap map,
                                           ArrayRef<OpFoldResult> operands) {
   return makeComposedFoldedMinMax<AffineMinOp>(b, loc, map, operands);
 }
 
 OpFoldResult
-mlir::makeComposedFoldedAffineMax(OpBuilder &b, Location loc, AffineMap map,
+mlir::affine::makeComposedFoldedAffineMax(OpBuilder &b, Location loc,
+                                          AffineMap map,
                                           ArrayRef<OpFoldResult> operands) {
   return makeComposedFoldedMinMax<AffineMaxOp>(b, loc, map, operands);
 }
 
 /// Fully compose map with operands and canonicalize the result.
 /// Return the `createOrFold`'ed AffineApply op.
 static Value createFoldedComposedAffineApply(OpBuilder &b, Location loc,
                                              AffineMap map,
                                              ValueRange operandsRef) {
   SmallVector<Value, 4> operands(operandsRef.begin(), operandsRef.end());
   fullyComposeAffineMapAndOperands(&map, &operands);
   canonicalizeMapAndOperands(&map, &operands);
   return b.createOrFold<AffineApplyOp>(loc, map, operands);
 }
 
-SmallVector<Value, 4> mlir::applyMapToValues(OpBuilder &b, Location loc,
-                                             AffineMap map, ValueRange values) {
+SmallVector<Value, 4> mlir::affine::applyMapToValues(OpBuilder &b, Location loc,
+                                                     AffineMap map,
+                                                     ValueRange values) {
   SmallVector<Value, 4> res;
   res.reserve(map.getNumResults());
   unsigned numDims = map.getNumDims(), numSym = map.getNumSymbols();
   // For each `expr` in `map`, applies the `expr` to the values extracted from
   // ranges. If the resulting application can be folded into a Value, the
   // folding occurs eagerly.
   for (auto expr : map.getResults()) {
     AffineMap map = AffineMap::get(numDims, numSym, expr);
if (it == seenSymbols.end()) {
       symRemapping[i] = it->second;
     }
   }
   *mapOrSet = mapOrSet->replaceDimsAndSymbols(dimRemapping, symRemapping,
                                               nextDim, nextSym);
   *operands = resultOperands;
 }
 
-void mlir::canonicalizeMapAndOperands(AffineMap *map,
-                                      SmallVectorImpl<Value> *operands) {
+void mlir::affine::canonicalizeMapAndOperands(
+    AffineMap *map, SmallVectorImpl<Value> *operands) {
   canonicalizeMapOrSetAndOperands<AffineMap>(map, operands);
 }
 
-void mlir::canonicalizeSetAndOperands(IntegerSet *set,
-                                      SmallVectorImpl<Value> *operands) {
+void mlir::affine::canonicalizeSetAndOperands(
+    IntegerSet *set, SmallVectorImpl<Value> *operands) {
   canonicalizeMapOrSetAndOperands<IntegerSet>(set, operands);
 }
 
 namespace {
 /// Simplify AffineApply, AffineLoad, and AffineStore operations by composing
 /// maps that supply results into them.
 ///
 template <typename AffineOpTy>
Speculation::Speculatability AffineForOp::getSpeculatability() {
   // For Step != 1, the loop may not terminate.  We can add more smarts here if
   // needed.
   return getStep() == 1 ? Speculation::RecursivelySpeculatable
                         : Speculation::NotSpeculatable;
 }
 
 /// Returns true if the provided value is the induction variable of a
 /// AffineForOp.
-bool mlir::isAffineForInductionVar(Value val) {
+bool mlir::affine::isAffineForInductionVar(Value val) {
   return getForInductionVarOwner(val) != AffineForOp();
 }
 
-bool mlir::isAffineParallelInductionVar(Value val) {
+bool mlir::affine::isAffineParallelInductionVar(Value val) {
   return getAffineParallelInductionVarOwner(val) != nullptr;
 }
 
-bool mlir::isAffineInductionVar(Value val) {
+bool mlir::affine::isAffineInductionVar(Value val) {
   return isAffineForInductionVar(val) || isAffineParallelInductionVar(val);
 }
 
-AffineForOp mlir::getForInductionVarOwner(Value val) {
+AffineForOp mlir::affine::getForInductionVarOwner(Value val) {
   auto ivArg = val.dyn_cast<BlockArgument>();
   if (!ivArg || !ivArg.getOwner())
     return AffineForOp();
   auto *containingInst = ivArg.getOwner()->getParent()->getParentOp();
   if (auto forOp = dyn_cast<AffineForOp>(containingInst))
     // Check to make sure `val` is the induction variable, not an iter_arg.
     return forOp.getInductionVar() == val ? forOp : AffineForOp();
   return AffineForOp();
 }
 
-AffineParallelOp mlir::getAffineParallelInductionVarOwner(Value val) {
+AffineParallelOp mlir::affine::getAffineParallelInductionVarOwner(Value val) {
   auto ivArg = val.dyn_cast<BlockArgument>();
   if (!ivArg || !ivArg.getOwner())
     return nullptr;
   Operation *containingOp = ivArg.getOwner()->getParentOp();
   auto parallelOp = dyn_cast<AffineParallelOp>(containingOp);
   if (parallelOp && llvm::is_contained(parallelOp.getIVs(), val))
     return parallelOp;
   return nullptr;
 }
 
 /// Extracts the induction variables from a list of AffineForOps and returns
 /// them.
-void mlir::extractForInductionVars(ArrayRef<AffineForOp> forInsts,
+void mlir::affine::extractForInductionVars(ArrayRef<AffineForOp> forInsts,
                                            SmallVectorImpl<Value> *ivs) {
   ivs->reserve(forInsts.size());
   for (auto forInst : forInsts)
     ivs->push_back(forInst.getInductionVar());
 }
 
-void mlir::extractInductionVars(ArrayRef<mlir::Operation *> affineOps,
+void mlir::affine::extractInductionVars(ArrayRef<mlir::Operation *> affineOps,
                                         SmallVectorImpl<mlir::Value> &ivs) {
   ivs.reserve(affineOps.size());
   for (Operation *op : affineOps) {
     // Add constraints from forOp's bounds.
     if (auto forOp = dyn_cast<AffineForOp>(op))
       ivs.push_back(forOp.getInductionVar());
     else if (auto parallelOp = dyn_cast<AffineParallelOp>(op))
       for (size_t i = 0; i < parallelOp.getBody()->getNumArguments(); i++)
         ivs.push_back(parallelOp.getBody()->getArgument(i));
buildAffineLoopFromValues(OpBuilder &builder, Location loc, Value lb, Value ub,
   if (lbConst && ubConst)
     return buildAffineLoopFromConstants(builder, loc, lbConst.value(),
                                         ubConst.value(), step, bodyBuilderFn);
   return builder.create<AffineForOp>(loc, lb, builder.getDimIdentityMap(), ub,
                                      builder.getDimIdentityMap(), step,
                                      /*iterArgs=*/std::nullopt, bodyBuilderFn);
 }
 
-void mlir::buildAffineLoopNest(
+void mlir::affine::buildAffineLoopNest(
     OpBuilder &builder, Location loc, ArrayRef<int64_t> lbs,
     ArrayRef<int64_t> ubs, ArrayRef<int64_t> steps,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilderFn) {
   buildAffineLoopNestImpl(builder, loc, lbs, ubs, steps, bodyBuilderFn,
                           buildAffineLoopFromConstants);
 }
 
-void mlir::buildAffineLoopNest(
+void mlir::affine::buildAffineLoopNest(
     OpBuilder &builder, Location loc, ValueRange lbs, ValueRange ubs,
     ArrayRef<int64_t> steps,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilderFn) {
   buildAffineLoopNestImpl(builder, loc, lbs, ubs, steps, bodyBuilderFn,
                           buildAffineLoopFromValues);
 }
 
-AffineForOp mlir::replaceForOpWithNewYields(OpBuilder &b, AffineForOp loop,
+AffineForOp mlir::affine::replaceForOpWithNewYields(OpBuilder &b,
+                                                    AffineForOp loop,
                                                     ValueRange newIterOperands,
                                                     ValueRange newYieldedValues,
                                                     ValueRange newIterArgs,
                                                     bool replaceLoopResults) {
   assert(newIterOperands.size() == newYieldedValues.size() &&
          "newIterOperands must be of the same size as newYieldedValues");
   // Create a new loop before the existing one, with the extra operands.
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(loop);
   auto operands = llvm::to_vector<4>(loop.getIterOperands());
   operands.append(newIterOperands.begin(), newIterOperands.end());
   SmallVector<Value, 4> lbOperands(loop.getLowerBoundOperands());

mlir/lib/Dialect/Affine/IR/AffineValueMap.cpp

 //===- AffineValueMap.cpp - MLIR Affine Value Map Class -------------------===//
 //
 // 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/Dialect/Affine/IR/AffineValueMap.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 AffineValueMap::AffineValueMap(AffineMap map, ValueRange operands,
                                ValueRange results)
     : map(map), operands(operands.begin(), operands.end()),
       results(results.begin(), results.end()) {}
 
 void AffineValueMap::reset(AffineMap map, ValueRange operands,
                            ValueRange results) {

mlir/lib/Dialect/Affine/IR/ValueBoundsOpInterfaceImpl.cpp

 //===- ValueBoundsOpInterfaceImpl.cpp - Impl. of ValueBoundsOpInterface ---===//
 //
 // 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/Dialect/Affine/IR/ValueBoundsOpInterfaceImpl.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Interfaces/ValueBoundsOpInterface.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace mlir {
 namespace {
 
 struct AffineApplyOpInterface
     : public ValueBoundsOpInterface::ExternalModel<AffineApplyOpInterface,
                                                    AffineApplyOp> {
   void populateBoundsForIndexValue(Operation *op, Value value,

mlir/lib/Dialect/Affine/TransformOps/AffineTransformOps.cpp

 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 using namespace mlir::transform;
 
 //===----------------------------------------------------------------------===//
 // SimplifyBoundedAffineOpsOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SimplifyBoundedAffineOpsOp::verify() {
   if (getLowerBounds().size() != getBoundedValues().size())

mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp

 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <algorithm>
 #include <optional>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINEDATACOPYGENERATION
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-data-copy-generate"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// Replaces all loads and stores on memref's living in 'slowMemorySpace' by
 /// introducing copy operations to transfer data into `fastMemorySpace` and
 /// rewriting the original load's/store's to instead load/store from the
 /// allocated fast memory buffers. Additional options specify the identifier
 /// corresponding to the fast memory space and the amount of fast memory space
 /// available. The pass traverses through the nesting structure, recursing to
 /// inner levels if necessary to determine at what depth copies need to be
 /// placed so that the allocated buffers fit within the memory capacity
 /// provided.
 // TODO: We currently can't generate copies correctly when stores
 // are strided. Check for strided stores.
 struct AffineDataCopyGeneration
-    : public impl::AffineDataCopyGenerationBase<AffineDataCopyGeneration> {
+    : public affine::impl::AffineDataCopyGenerationBase<
+          AffineDataCopyGeneration> {
   AffineDataCopyGeneration() = default;
   explicit AffineDataCopyGeneration(unsigned slowMemorySpace,
                                     unsigned fastMemorySpace,
                                     unsigned tagMemorySpace,
                                     int minDmaTransferSize,
                                     uint64_t fastMemCapacityBytes) {
     this->slowMemorySpace = slowMemorySpace;
     this->fastMemorySpace = fastMemorySpace;

 
 } // namespace
 
 /// Generates copies for memref's living in 'slowMemorySpace' into newly created
 /// buffers in 'fastMemorySpace', and replaces memory operations to the former
 /// by the latter. Only load op's handled for now.
 /// TODO: extend this to store op's.
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createAffineDataCopyGenerationPass(unsigned slowMemorySpace,
-                                         unsigned fastMemorySpace,
-                                         unsigned tagMemorySpace,
-                                         int minDmaTransferSize,
-                                         uint64_t fastMemCapacityBytes) {
+mlir::affine::createAffineDataCopyGenerationPass(
+    unsigned slowMemorySpace, unsigned fastMemorySpace, unsigned tagMemorySpace,
+    int minDmaTransferSize, uint64_t fastMemCapacityBytes) {
   return std::make_unique<AffineDataCopyGeneration>(
       slowMemorySpace, fastMemorySpace, tagMemorySpace, minDmaTransferSize,
       fastMemCapacityBytes);
 }
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createAffineDataCopyGenerationPass() {
+mlir::affine::createAffineDataCopyGenerationPass() {
   return std::make_unique<AffineDataCopyGeneration>();
 }
 
 /// Generate copies for this block. The block is partitioned into separate
 /// ranges: each range is either a sequence of one or more operations starting
 /// and ending with an affine load or store op, or just an affine.forop (which
 /// could have other affine for op's nested within).
 void AffineDataCopyGeneration::runOnBlock(Block *block,

mlir/lib/Dialect/Affine/Transforms/AffineExpandIndexOps.cpp

 #include "mlir/Dialect/Affine/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Transforms/Transforms.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINEEXPANDINDEXOPS
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 /// Lowers `affine.delinearize_index` into a sequence of division and remainder
 /// operations.
 struct LowerDelinearizeIndexOps
     : public OpRewritePattern<AffineDelinearizeIndexOp> {
   using OpRewritePattern<AffineDelinearizeIndexOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(AffineDelinearizeIndexOp op,
                                 PatternRewriter &rewriter) const override {
     FailureOr<SmallVector<Value>> multiIndex =
         delinearizeIndex(rewriter, op->getLoc(), op.getLinearIndex(),
                          llvm::to_vector(op.getBasis()));
     if (failed(multiIndex))
       return failure();
     rewriter.replaceOp(op, *multiIndex);
     return success();
   }
 };
 
 class ExpandAffineIndexOpsPass
-    : public impl::AffineExpandIndexOpsBase<ExpandAffineIndexOpsPass> {
+    : public affine::impl::AffineExpandIndexOpsBase<ExpandAffineIndexOpsPass> {
 public:
   ExpandAffineIndexOpsPass() = default;
 
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns(context);
     populateAffineExpandIndexOpsPatterns(patterns);
     if (failed(
             applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
       return signalPassFailure();
   }
 };
 
 } // namespace
 
-void mlir::populateAffineExpandIndexOpsPatterns(RewritePatternSet &patterns) {
+void mlir::affine::populateAffineExpandIndexOpsPatterns(
+    RewritePatternSet &patterns) {
   patterns.insert<LowerDelinearizeIndexOps>(patterns.getContext());
 }
 
-std::unique_ptr<Pass> mlir::createAffineExpandIndexOpsPass() {
+std::unique_ptr<Pass> mlir::affine::createAffineExpandIndexOpsPass() {
   return std::make_unique<ExpandAffineIndexOpsPass>();
 }

mlir/lib/Dialect/Affine/Transforms/AffineLoopInvariantCodeMotion.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINELOOPINVARIANTCODEMOTION
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "licm"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// Loop invariant code motion (LICM) pass.
 /// TODO: The pass is missing zero-trip tests.
 /// TODO: Check for the presence of side effects before hoisting.
 /// TODO: This code should be removed once the new LICM pass can handle its
 ///       uses.
 struct LoopInvariantCodeMotion
-    : public impl::AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
+    : public affine::impl::AffineLoopInvariantCodeMotionBase<
+          LoopInvariantCodeMotion> {
   void runOnOperation() override;
   void runOnAffineForOp(AffineForOp forOp);
 };
 } // namespace
 
 static bool
 checkInvarianceOfNestedIfOps(AffineIfOp ifOp, Value indVar, ValueRange iterArgs,
                              SmallPtrSetImpl<Operation *> &opsWithUsers,
                              SmallPtrSetImpl<Operation *> &opsToHoist);
 static bool isOpLoopInvariant(Operation &op, Value indVar, ValueRange iterArgs,
                               SmallPtrSetImpl<Operation *> &opsWithUsers,
                               SmallPtrSetImpl<Operation *> &opsToHoist);
 
 static bool
 areAllOpsInTheBlockListInvariant(Region &blockList, Value indVar,
                                  ValueRange iterArgs,
                                  SmallPtrSetImpl<Operation *> &opsWithUsers,
                                  SmallPtrSetImpl<Operation *> &opsToHoist);
 
 // Returns true if the individual op is loop invariant.
-bool isOpLoopInvariant(Operation &op, Value indVar, ValueRange iterArgs,
+static bool isOpLoopInvariant(Operation &op, Value indVar, ValueRange iterArgs,
                               SmallPtrSetImpl<Operation *> &opsWithUsers,
                               SmallPtrSetImpl<Operation *> &opsToHoist) {
   LLVM_DEBUG(llvm::dbgs() << "iterating on op: " << op;);
 
   if (auto ifOp = dyn_cast<AffineIfOp>(op)) {
     if (!checkInvarianceOfNestedIfOps(ifOp, indVar, iterArgs, opsWithUsers,
                                       opsToHoist))
       return false;
   } else if (auto forOp = dyn_cast<AffineForOp>(op)) {
     if (!areAllOpsInTheBlockListInvariant(forOp.getLoopBody(), indVar, iterArgs,
static bool isOpLoopInvariant(Operation &op, Value indVar, ValueRange iterArgs,
   }
 
   // If no operand was loop variant, mark this op for motion.
   opsToHoist.insert(&op);
   return true;
 }
 
 // Checks if all ops in a region (i.e. list of blocks) are loop invariant.
-bool areAllOpsInTheBlockListInvariant(
-    Region &blockList, Value indVar, ValueRange iterArgs,
+static bool
+areAllOpsInTheBlockListInvariant(Region &blockList, Value indVar,
+                                 ValueRange iterArgs,
                                  SmallPtrSetImpl<Operation *> &opsWithUsers,
                                  SmallPtrSetImpl<Operation *> &opsToHoist) {
 
   for (auto &b : blockList) {
     for (auto &op : b) {
       if (!isOpLoopInvariant(op, indVar, iterArgs, opsWithUsers, opsToHoist))
         return false;
     }
   }
 
   return true;
 }
 
 // Returns true if the affine.if op can be hoisted.
-bool checkInvarianceOfNestedIfOps(AffineIfOp ifOp, Value indVar,
-                                  ValueRange iterArgs,
-                                  SmallPtrSetImpl<Operation *> &opsWithUsers,
-                                  SmallPtrSetImpl<Operation *> &opsToHoist) {
+static bool
+checkInvarianceOfNestedIfOps(AffineIfOp ifOp, Value indVar, ValueRange iterArgs,
   if (!areAllOpsInTheBlockListInvariant(ifOp.getThenRegion(), indVar, iterArgs,
                                         opsWithUsers, opsToHoist))
     return false;
 
   if (!areAllOpsInTheBlockListInvariant(ifOp.getElseRegion(), indVar, iterArgs,
                                         opsWithUsers, opsToHoist))
     return false;
 
void LoopInvariantCodeMotion::runOnOperation() {
   // the outer loop, which in turn can be further LICM'ed.
   getOperation().walk([&](AffineForOp op) {
     LLVM_DEBUG(op->print(llvm::dbgs() << "\nOriginal loop\n"));
     runOnAffineForOp(op);
   });
 }
 
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createAffineLoopInvariantCodeMotionPass() {
+mlir::affine::createAffineLoopInvariantCodeMotionPass() {
   return std::make_unique<LoopInvariantCodeMotion>();
 }

mlir/lib/Dialect/Affine/Transforms/AffineLoopNormalize.cpp

 
 #include "mlir/Dialect/Affine/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINELOOPNORMALIZE
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// Normalize affine.parallel ops so that lower bounds are 0 and steps are 1.
 /// As currently implemented, this pass cannot fail, but it might skip over ops
 /// that are already in a normalized form.
 struct AffineLoopNormalizePass
-    : public impl::AffineLoopNormalizeBase<AffineLoopNormalizePass> {
+    : public affine::impl::AffineLoopNormalizeBase<AffineLoopNormalizePass> {
   explicit AffineLoopNormalizePass(bool promoteSingleIter) {
     this->promoteSingleIter = promoteSingleIter;
   }
 
   void runOnOperation() override {
     getOperation().walk([&](Operation *op) {
       if (auto affineParallel = dyn_cast<AffineParallelOp>(op))
         normalizeAffineParallel(affineParallel);
       else if (auto affineFor = dyn_cast<AffineForOp>(op))
         (void)normalizeAffineFor(affineFor, promoteSingleIter);
     });
   }
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createAffineLoopNormalizePass(bool promoteSingleIter) {
+mlir::affine::createAffineLoopNormalizePass(bool promoteSingleIter) {
   return std::make_unique<AffineLoopNormalizePass>(promoteSingleIter);
 }

mlir/lib/Dialect/Affine/Transforms/AffineParallelize.cpp

 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Affine/Passes.h.inc"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "llvm/Support/Debug.h"
 #include <deque>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINEPARALLELIZE
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-parallel"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 /// Convert all parallel affine.for op into 1-D affine.parallel op.
 struct AffineParallelize
-    : public impl::AffineParallelizeBase<AffineParallelize> {
+    : public affine::impl::AffineParallelizeBase<AffineParallelize> {
   void runOnOperation() override;
 };
 
 /// Descriptor of a potentially parallelizable loop.
 struct ParallelizationCandidate {
   ParallelizationCandidate(AffineForOp l, SmallVector<LoopReduction> &&r)
       : loop(l), reductions(std::move(r)) {}
 
for (const ParallelizationCandidate &candidate : parallelizableLoops) {
     } else {
       LLVM_DEBUG(llvm::dbgs() << "[" DEBUG_TYPE "] too many nested loops\n"
                               << loop);
     }
   }
 }
 
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createAffineParallelizePass() {
+mlir::affine::createAffineParallelizePass() {
   return std::make_unique<AffineParallelize>();
 }

mlir/lib/Dialect/Affine/Transforms/AffineScalarReplacement.cpp

 
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Dominance.h"
 #include "mlir/Support/LogicalResult.h"
 #include <algorithm>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINESCALARREPLACEMENT
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-scalrep"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 struct AffineScalarReplacement
-    : public impl::AffineScalarReplacementBase<AffineScalarReplacement> {
+    : public affine::impl::AffineScalarReplacementBase<
+          AffineScalarReplacement> {
   void runOnOperation() override;
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createAffineScalarReplacementPass() {
+mlir::affine::createAffineScalarReplacementPass() {
   return std::make_unique<AffineScalarReplacement>();
 }
 
 void AffineScalarReplacement::runOnOperation() {
   affineScalarReplace(getOperation(), getAnalysis<DominanceInfo>(),
                       getAnalysis<PostDominanceInfo>());
 }

mlir/lib/Dialect/Affine/Transforms/DecomposeAffineOps.cpp

 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Transforms/Transforms.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "llvm/Support/Debug.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 #define DEBUG_TYPE "decompose-affine-ops"
 #define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "]: ")
 #define DBGSNL() (llvm::dbgs() << "\n")
 
 /// Count the number of loops surrounding `operand` such that operand could be
 /// hoisted above.
 /// Stop counting at the first loop over which the operand cannot be hoisted.
 static int64_t numEnclosingInvariantLoops(OpOperand &operand) {
   int64_t count = 0;
   Operation *currentOp = operand.getOwner();
   while (auto loopOp = currentOp->getParentOfType<LoopLikeOpInterface>()) {
     if (!loopOp.isDefinedOutsideOfLoop(operand.get()))
       break;
     currentOp = loopOp;
     count++;
   }
   return count;
 }
 
-void mlir::reorderOperandsByHoistability(RewriterBase &rewriter,
+void mlir::affine::reorderOperandsByHoistability(RewriterBase &rewriter,
                                                  AffineApplyOp op) {
   SmallVector<int64_t> numInvariant = llvm::to_vector(
       llvm::map_range(op->getOpOperands(), [&](OpOperand &operand) {
         return numEnclosingInvariantLoops(operand);
       }));
 
   int64_t numOperands = op.getNumOperands();
   SmallVector<int64_t> operandPositions =
       llvm::to_vector(llvm::seq<int64_t>(0, numOperands));
static AffineApplyOp createSubApply(RewriterBase &rewriter,
   AffineMap m = originalOp.getAffineMap();
   auto rhsMap = AffineMap::get(m.getNumDims(), m.getNumSymbols(), expr, ctx);
   SmallVector<Value> rhsOperands = originalOp->getOperands();
   canonicalizeMapAndOperands(&rhsMap, &rhsOperands);
   return rewriter.create<AffineApplyOp>(originalOp.getLoc(), rhsMap,
                                         rhsOperands);
 }
 
-FailureOr<AffineApplyOp> mlir::decompose(RewriterBase &rewriter,
+FailureOr<AffineApplyOp> mlir::affine::decompose(RewriterBase &rewriter,
                                                  AffineApplyOp op) {
   // 1. Preconditions: only handle dimensionless AffineApplyOp maps with a
   // top-level binary expression that we can reassociate (i.e. add or mul).
   AffineMap m = op.getAffineMap();
   if (m.getNumDims() > 0)
     return rewriter.notifyMatchFailure(op, "expected no dims");
 
   AffineExpr remainingExp = m.getResult(0);
   auto binExpr = remainingExp.dyn_cast<AffineBinaryOpExpr>();

mlir/lib/Dialect/Affine/Transforms/LoopCoalescing.cpp

 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/Transforms/Passes.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/Support/Debug.h"
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_LOOPCOALESCING
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define PASS_NAME "loop-coalescing"
 #define DEBUG_TYPE PASS_NAME
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 struct LoopCoalescingPass
-    : public impl::LoopCoalescingBase<LoopCoalescingPass> {
+    : public affine::impl::LoopCoalescingBase<LoopCoalescingPass> {
 
   void runOnOperation() override {
     func::FuncOp func = getOperation();
     func.walk<WalkOrder::PreOrder>([](Operation *op) {
       if (auto scfForOp = dyn_cast<scf::ForOp>(op))
         (void)coalescePerfectlyNestedLoops(scfForOp);
       else if (auto affineForOp = dyn_cast<AffineForOp>(op))
         (void)coalescePerfectlyNestedLoops(affineForOp);
     });
   }
 };
 
 } // namespace
 
-std::unique_ptr<OperationPass<func::FuncOp>> mlir::createLoopCoalescingPass() {
+std::unique_ptr<OperationPass<func::FuncOp>>
+mlir::affine::createLoopCoalescingPass() {
   return std::make_unique<LoopCoalescingPass>();
 }

mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iomanip>
 #include <optional>
 #include <sstream>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINELOOPFUSION
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-loop-fusion"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 /// Loop fusion pass. This pass currently supports a greedy fusion policy,
 /// which fuses loop nests with single-writer/single-reader memref dependences
 /// with the goal of improving locality.
 
 // TODO: Support fusion of source loop nests which write to multiple
 // memrefs, where each memref can have multiple users (if profitable).
 // TODO: Extend this pass to check for fusion preventing dependences,
 // and add support for more general loop fusion algorithms.
 
-struct LoopFusion : public impl::AffineLoopFusionBase<LoopFusion> {
+struct LoopFusion : public affine::impl::AffineLoopFusionBase<LoopFusion> {
   LoopFusion() = default;
   LoopFusion(unsigned fastMemorySpace, uint64_t localBufSizeThresholdBytes,
              bool maximalFusion, enum FusionMode affineFusionMode) {
     this->fastMemorySpace = fastMemorySpace;
     this->localBufSizeThreshold = localBufSizeThresholdBytes / 1024;
     this->maximalFusion = maximalFusion;
     this->affineFusionMode = affineFusionMode;
   }
do {
 
         // Check the feasibility of fusing src loop nest into dst loop nest
         // at loop depths in range [1, dstLoopDepthTest].
         unsigned maxLegalFusionDepth = 0;
         SmallVector<ComputationSliceState, 8> depthSliceUnions;
         depthSliceUnions.resize(dstLoopDepthTest);
         FusionStrategy strategy(FusionStrategy::ProducerConsumer);
         for (unsigned i = 1; i <= dstLoopDepthTest; ++i) {
-          FusionResult result = mlir::canFuseLoops(
+          FusionResult result = affine::canFuseLoops(
               srcAffineForOp, dstAffineForOp,
               /*dstLoopDepth=*/i, &depthSliceUnions[i - 1], strategy);
 
           if (result.value == FusionResult::Success)
             maxLegalFusionDepth = i;
         }
 
         if (maxLegalFusionDepth == 0) {
while (findSiblingNodeToFuse(dstNode, &visitedSibNodeIds, &idAndMemref)) {
       auto sibAffineForOp = cast<AffineForOp>(sibNode->op);
 
       // Compute loop depth and slice union for fusion.
       SmallVector<ComputationSliceState, 8> depthSliceUnions;
       depthSliceUnions.resize(dstLoopDepthTest);
       unsigned maxLegalFusionDepth = 0;
       FusionStrategy strategy(memref);
       for (unsigned i = 1; i <= dstLoopDepthTest; ++i) {
-        FusionResult result = mlir::canFuseLoops(
+        FusionResult result = affine::canFuseLoops(
             sibAffineForOp, dstAffineForOp,
             /*dstLoopDepth=*/i, &depthSliceUnions[i - 1], strategy);
 
         if (result.value == FusionResult::Success)
           maxLegalFusionDepth = i;
       }
 
       // Skip if fusion is not feasible at any loop depths.
while (findSiblingNodeToFuse(dstNode, &visitedSibNodeIds, &idAndMemref)) {
       assert(bestDstLoopDepth > 0 && "Unexpected loop fusion depth");
       assert(!depthSliceUnions[bestDstLoopDepth - 1].isEmpty() &&
              "Fusion depth has no computed slice union");
       // Check if source loop is being inserted in the innermost
       // destination loop. Based on this, the fused loop may be optimized
       // further inside `fuseLoops`.
       bool isInnermostInsertion = (bestDstLoopDepth == dstLoopDepthTest);
       // Fuse computation slice of 'sibLoopNest' into 'dstLoopNest'.
-      mlir::fuseLoops(sibAffineForOp, dstAffineForOp,
+      affine::fuseLoops(sibAffineForOp, dstAffineForOp,
                         depthSliceUnions[bestDstLoopDepth - 1],
                         isInnermostInsertion);
 
       auto dstForInst = cast<AffineForOp>(dstNode->op);
       // Update operation position of fused loop nest (if needed).
       if (insertPointInst != dstForInst) {
         dstForInst->moveBefore(insertPointInst);
       }
       // Update data dependence graph state post fusion.
       updateStateAfterSiblingFusion(sibNode, dstNode);

 }
 
 void LoopFusion::runOnOperation() {
   for (Region &region : getOperation()->getRegions())
     for (Block &block : region.getBlocks())
       runOnBlock(&block);
 }
 
-std::unique_ptr<Pass>
-mlir::createLoopFusionPass(unsigned fastMemorySpace,
-                           uint64_t localBufSizeThreshold, bool maximalFusion,
-                           enum FusionMode affineFusionMode) {
+std::unique_ptr<Pass> mlir::affine::createLoopFusionPass(
+    unsigned fastMemorySpace, uint64_t localBufSizeThreshold,
+    bool maximalFusion, enum FusionMode affineFusionMode) {
   return std::make_unique<LoopFusion>(fastMemorySpace, localBufSizeThreshold,
                                       maximalFusion, affineFusionMode);
 }

mlir/lib/Dialect/Affine/Transforms/LoopTiling.cpp

 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IRMapping.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINELOOPTILING
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 using namespace mlir;
+using namespace mlir::affine;
 
 #define DEBUG_TYPE "affine-loop-tile"
 
 namespace {
 
 /// A pass to perform loop tiling on all suitable loop nests of a Function.
-struct LoopTiling : public impl::AffineLoopTilingBase<LoopTiling> {
+struct LoopTiling : public affine::impl::AffineLoopTilingBase<LoopTiling> {
   LoopTiling() = default;
   explicit LoopTiling(uint64_t cacheSizeBytes, bool avoidMaxMinBounds = true)
       : avoidMaxMinBounds(avoidMaxMinBounds) {
     this->cacheSizeInKiB = cacheSizeBytes / 1024;
   }
 
   void runOnOperation() override;
   void getTileSizes(ArrayRef<AffineForOp> band,
                     SmallVectorImpl<unsigned> *tileSizes);
 
   // Default tile size if nothing is provided.
   constexpr static unsigned kDefaultTileSize = 4;
 
   // If true, tile sizes are set to avoid max/min in bounds if possible.
   bool avoidMaxMinBounds = true;
 };
 
 } // namespace
 
 /// Creates a pass to perform loop tiling on all suitable loop nests of a
 /// Function.
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createLoopTilingPass(uint64_t cacheSizeBytes) {
+mlir::affine::createLoopTilingPass(uint64_t cacheSizeBytes) {
   return std::make_unique<LoopTiling>(cacheSizeBytes);
 }
-std::unique_ptr<OperationPass<func::FuncOp>> mlir::createLoopTilingPass() {
+std::unique_ptr<OperationPass<func::FuncOp>>
+mlir::affine::createLoopTilingPass() {
   return std::make_unique<LoopTiling>();
 }
 
 /// Reduces each tile size to the largest divisor of the corresponding trip
 /// count (if the trip count is known).
 static void adjustToDivisorsOfTripCounts(ArrayRef<AffineForOp> band,
                                          SmallVectorImpl<unsigned> *tileSizes) {
   assert(band.size() == tileSizes->size() && "invalid tile size count");

 /// Checks whether hyper-rectangular loop tiling of the nest represented by
 /// `origLoops` is valid. The validity condition is from Irigoin and Triolet,
 /// which states that two tiles cannot depend on each other. We simplify such
 /// condition to just checking whether there is any negative dependence
 /// direction, since we have the prior knowledge that the tiling results will be
 /// hyper-rectangles, which are scheduled in the lexicographically increasing
 /// order on the vector of loop indices. This function will return failure when
 /// any dependence component is negative along any of `origLoops`.
-static bool checkTilingLegality(MutableArrayRef<mlir::AffineForOp> origLoops) {
+static bool checkTilingLegality(MutableArrayRef<AffineForOp> origLoops) {
   assert(!origLoops.empty() && "no original loops provided");
 
   // We first find out all dependences we intend to check.
   SmallVector<Operation *, 8> loadAndStoreOps;
   origLoops[0]->walk([&](Operation *op) {
     if (isa<AffineReadOpInterface, AffineWriteOpInterface>(op))
       loadAndStoreOps.push_back(op);
   });

mlir/lib/Dialect/Affine/Transforms/LoopUnroll.cpp

 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINELOOPUNROLL
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-loop-unroll"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 // TODO: this is really a test pass and should be moved out of dialect
 // transforms.
 
 /// Loop unrolling pass. Unrolls all innermost loops unless full unrolling and a
 /// full unroll threshold was specified, in which case, fully unrolls all loops
 /// with trip count less than the specified threshold. The latter is for testing
 /// purposes, especially for testing outer loop unrolling.
-struct LoopUnroll : public impl::AffineLoopUnrollBase<LoopUnroll> {
+struct LoopUnroll : public affine::impl::AffineLoopUnrollBase<LoopUnroll> {
   // Callback to obtain unroll factors; if this has a callable target, takes
   // precedence over command-line argument or passed argument.
   const std::function<unsigned(AffineForOp)> getUnrollFactor;
 
   LoopUnroll() : getUnrollFactor(nullptr) {}
   LoopUnroll(const LoopUnroll &other)
 
       = default;
if (unrollFull)
     return loopUnrollFull(forOp);
   // Otherwise, unroll by the given unroll factor.
   if (unrollUpToFactor)
     return loopUnrollUpToFactor(forOp, unrollFactor);
   return loopUnrollByFactor(forOp, unrollFactor, /*annotateFn=*/nullptr,
                             cleanUpUnroll);
 }
 
-std::unique_ptr<OperationPass<func::FuncOp>> mlir::createLoopUnrollPass(
+std::unique_ptr<OperationPass<func::FuncOp>> mlir::affine::createLoopUnrollPass(
     int unrollFactor, bool unrollUpToFactor, bool unrollFull,
     const std::function<unsigned(AffineForOp)> &getUnrollFactor) {
   return std::make_unique<LoopUnroll>(
       unrollFactor == -1 ? std::nullopt : std::optional<unsigned>(unrollFactor),
       unrollUpToFactor, unrollFull, getUnrollFactor);
 }

mlir/lib/Dialect/Affine/Transforms/LoopUnrollAndJam.cpp

 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/IRMapping.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/CommandLine.h"
 #include <optional>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINELOOPUNROLLANDJAM
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-loop-unroll-jam"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 /// Loop unroll jam pass. Currently, this just unroll jams the first
 /// outer loop in a Function.
 struct LoopUnrollAndJam
-    : public impl::AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
+    : public affine::impl::AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
   explicit LoopUnrollAndJam(
       std::optional<unsigned> unrollJamFactor = std::nullopt) {
     if (unrollJamFactor)
       this->unrollJamFactor = *unrollJamFactor;
   }
 
   void runOnOperation() override;
 };
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createLoopUnrollAndJamPass(int unrollJamFactor) {
+mlir::affine::createLoopUnrollAndJamPass(int unrollJamFactor) {
   return std::make_unique<LoopUnrollAndJam>(
       unrollJamFactor == -1 ? std::nullopt
                             : std::optional<unsigned>(unrollJamFactor));
 }
 
 void LoopUnrollAndJam::runOnOperation() {
   if (getOperation().isExternal())
     return;
 
   // Currently, just the outermost loop from the first loop nest is
   // unroll-and-jammed by this pass. However, runOnAffineForOp can be called on
   // any for operation.
   auto &entryBlock = getOperation().front();
   if (auto forOp = dyn_cast<AffineForOp>(entryBlock.front()))
     (void)loopUnrollJamByFactor(forOp, unrollJamFactor);
 }

mlir/lib/Dialect/Affine/Transforms/PipelineDataTransfer.cpp

 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Debug.h"
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINEPIPELINEDATATRANSFER
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "affine-pipeline-data-transfer"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 struct PipelineDataTransfer
-    : public impl::AffinePipelineDataTransferBase<PipelineDataTransfer> {
+    : public affine::impl::AffinePipelineDataTransferBase<
+          PipelineDataTransfer> {
   void runOnOperation() override;
   void runOnAffineForOp(AffineForOp forOp);
 
   std::vector<AffineForOp> forOps;
 };
 
 } // namespace
 
 /// Creates a pass to pipeline explicit movement of data across levels of the
 /// memory hierarchy.
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createPipelineDataTransferPass() {
+mlir::affine::createPipelineDataTransferPass() {
   return std::make_unique<PipelineDataTransfer>();
 }
 
 // Returns the position of the tag memref operand given a DMA operation.
 // Temporary utility: will be replaced when DmaStart/DmaFinish abstract op's are
 // added.  TODO
 static unsigned getTagMemRefPos(Operation &dmaOp) {
   assert((isa<AffineDmaStartOp, AffineDmaWaitOp>(dmaOp)));
void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) {
   // Store shift for operation for later lookup for AffineApplyOp's.
   DenseMap<Operation *, unsigned> instShiftMap;
   for (auto &pair : startWaitPairs) {
     auto *dmaStartOp = pair.first;
     assert(isa<AffineDmaStartOp>(dmaStartOp));
     instShiftMap[dmaStartOp] = 0;
     // Set shifts for DMA start op's affine operand computation slices to 0.
     SmallVector<AffineApplyOp, 4> sliceOps;
-    mlir::createAffineComputationSlice(dmaStartOp, &sliceOps);
+    affine::createAffineComputationSlice(dmaStartOp, &sliceOps);
     if (!sliceOps.empty()) {
       for (auto sliceOp : sliceOps) {
         instShiftMap[sliceOp.getOperation()] = 0;
       }
     } else {
       // If a slice wasn't created, the reachable affine.apply op's from its
       // operands are the ones that go with it.
       SmallVector<Operation *, 4> affineApplyInsts;

mlir/lib/Dialect/Affine/Transforms/ReifyValueBounds.cpp

 //===- ReifyValueBounds.cpp --- Reify value bounds with affine ops ------*-===//
 //
 // 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/Dialect/Affine/Transforms/Transforms.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Interfaces/ValueBoundsOpInterface.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 FailureOr<OpFoldResult>
-mlir::reifyValueBound(OpBuilder &b, Location loc, presburger::BoundType type,
-                      Value value, std::optional<int64_t> dim, bool closedUB) {
+mlir::affine::reifyValueBound(OpBuilder &b, Location loc,
+                              presburger::BoundType type, Value value,
+                              std::optional<int64_t> dim, bool closedUB) {
   // We are trying to reify a bound for `value`. Construct a stop condition that
   // evaluates to "true" for any SSA value expect for `value`. I.e., the bound
   // will be computed in terms of any SSA values except for `value`. The first
   // such values are operands of the owner of `value`.
   auto stopCondition = [&](Value v, std::optional<int64_t> d) {
     // Reify in terms of SSA values that are different from `value`.
     return v != value;
   };
   return reifyValueBound(b, loc, type, value, dim, stopCondition, closedUB);
 }
 
-FailureOr<OpFoldResult> mlir::reifyValueBound(
+FailureOr<OpFoldResult> mlir::affine::reifyValueBound(
     OpBuilder &b, Location loc, presburger::BoundType type, Value value,
     std::optional<int64_t> dim,
     function_ref<bool(Value, std::optional<int64_t>)> stopCondition,
     bool closedUB) {
   // Compute bound.
   AffineMap boundMap;
   ValueDimList mapOperands;
   if (failed(ValueBoundsConstraintSet::computeBound(
if (isa<RankedTensorType>(value.getType())) {
       // A memref dimension is used: generate a memref.dim.
       operands.push_back(b.create<memref::DimOp>(loc, value, *dim));
     } else {
       llvm_unreachable("cannot generate DimOp for unsupported shaped type");
     }
   }
 
   // Simplify and return bound.
-  mlir::canonicalizeMapAndOperands(&boundMap, &operands);
+  affine::canonicalizeMapAndOperands(&boundMap, &operands);
   // Check for special cases where no affine.apply op is needed.
   if (boundMap.isSingleConstant()) {
     // Bound is a constant: return an IntegerAttr.
     return static_cast<OpFoldResult>(
         b.getIndexAttr(boundMap.getSingleConstantResult()));
   }
   // No affine.apply op is needed if the bound is a single SSA value.
   if (auto expr = boundMap.getResult(0).dyn_cast<AffineDimExpr>())
     return static_cast<OpFoldResult>(operands[expr.getPosition()]);
   if (auto expr = boundMap.getResult(0).dyn_cast<AffineSymbolExpr>())
     return static_cast<OpFoldResult>(
         operands[expr.getPosition() + boundMap.getNumDims()]);
   // General case: build affine.apply op.
   return static_cast<OpFoldResult>(
       b.create<AffineApplyOp>(loc, boundMap, operands).getResult());
 }

mlir/lib/Dialect/Affine/Transforms/SimplifyAffineStructures.cpp

 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_SIMPLIFYAFFINESTRUCTURES
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 #define DEBUG_TYPE "simplify-affine-structure"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// Simplifies affine maps and sets appearing in the operations of the Function.
 /// This part is mainly to test the simplifyAffineExpr method. In addition,
 /// all memrefs with non-trivial layout maps are converted to ones with trivial
 /// identity layout ones.
 struct SimplifyAffineStructures
-    : public impl::SimplifyAffineStructuresBase<SimplifyAffineStructures> {
+    : public affine::impl::SimplifyAffineStructuresBase<
+          SimplifyAffineStructures> {
   void runOnOperation() override;
 
   /// Utility to simplify an affine attribute and update its entry in the parent
   /// operation if necessary.
   template <typename AttributeT>
   void simplifyAndUpdateAttribute(Operation *op, StringAttr name,
                                   AttributeT attr) {
     auto &simplified = simplifiedAttributes[attr];
struct SimplifyAffineStructures
   }
 
   DenseMap<Attribute, Attribute> simplifiedAttributes;
 };
 
 } // namespace
 
 std::unique_ptr<OperationPass<func::FuncOp>>
-mlir::createSimplifyAffineStructuresPass() {
+mlir::affine::createSimplifyAffineStructuresPass() {
   return std::make_unique<SimplifyAffineStructures>();
 }
 
 void SimplifyAffineStructures::runOnOperation() {
   auto func = getOperation();
   simplifiedAttributes.clear();
   RewritePatternSet patterns(func.getContext());
   AffineApplyOp::getCanonicalizationPatterns(patterns, func.getContext());

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

 #include "mlir/IR/IRMapping.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 namespace mlir {
+namespace affine {
 #define GEN_PASS_DEF_AFFINEVECTORIZE
 #include "mlir/Dialect/Affine/Passes.h.inc"
+} // namespace affine
 } // namespace mlir
 
 using namespace mlir;
+using namespace affine;
 using namespace vector;
 
 ///
 /// Implements a high-level vectorization strategy on a Function.
 /// The abstraction used is that of super-vectors, which provide a single,
 /// compact, representation in the vector types, information that is expected
 /// to reduce the impact of the phase ordering problem
 ///

 
 /// Creates a vectorization pattern from the command line arguments.
 /// Up to 3-D patterns are supported.
 /// If the command line argument requests a pattern of higher order, returns an
 /// empty pattern list which will conservatively result in no vectorization.
 static std::optional<NestedPattern>
 makePattern(const DenseSet<Operation *> &parallelLoops, int vectorRank,
             ArrayRef<int64_t> fastestVaryingPattern) {
-  using matcher::For;
+  using affine::matcher::For;
   int64_t d0 = fastestVaryingPattern.empty() ? -1 : fastestVaryingPattern[0];
   int64_t d1 = fastestVaryingPattern.size() < 2 ? -1 : fastestVaryingPattern[1];
   int64_t d2 = fastestVaryingPattern.size() < 3 ? -1 : fastestVaryingPattern[2];
   switch (vectorRank) {
   case 1:
     return For(isVectorizableLoopPtrFactory(parallelLoops, d0));
   case 2:
     return For(isVectorizableLoopPtrFactory(parallelLoops, d0),
                For(isVectorizableLoopPtrFactory(parallelLoops, d1)));
   case 3:
     return For(isVectorizableLoopPtrFactory(parallelLoops, d0),
                For(isVectorizableLoopPtrFactory(parallelLoops, d1),
                    For(isVectorizableLoopPtrFactory(parallelLoops, d2))));
   default: {
     return std::nullopt;
   }
   }
 }
 
 static NestedPattern &vectorTransferPattern() {
-  static auto pattern = matcher::Op([](Operation &op) {
+  static auto pattern = affine::matcher::Op([](Operation &op) {
     return isa<vector::TransferReadOp, vector::TransferWriteOp>(op);
   });
   return pattern;
 }
 
 namespace {
 
 /// Base state for the vectorize pass.
 /// Command line arguments are preempted by non-empty pass arguments.
-struct Vectorize : public impl::AffineVectorizeBase<Vectorize> {
+struct Vectorize : public affine::impl::AffineVectorizeBase<Vectorize> {
   using Base::Base;
 
   void runOnOperation() override;
 };
 
 } // namespace
 
 static void vectorizeLoopIfProfitable(Operation *loop, unsigned depthInPattern,
for (AffineForOp loop : loops[i]) {
           return failure();
       }
     }
   }
 
   return success();
 }
 
-namespace mlir {
 
 /// External utility to vectorize affine loops in 'loops' using the n-D
 /// vectorization factors in 'vectorSizes'. By default, each vectorization
 /// factor is applied inner-to-outer to the loops of each loop nest.
 /// 'fastestVaryingPattern' can be optionally used to provide a different loop
 /// vectorization order.
 /// If `reductionLoops` is not empty, the given reduction loops may be
 /// vectorized along the reduction dimension.
 /// TODO: Vectorizing reductions is supported only for 1-D vectorization.
-void vectorizeAffineLoops(Operation *parentOp, DenseSet<Operation *> &loops,
-                          ArrayRef<int64_t> vectorSizes,
-                          ArrayRef<int64_t> fastestVaryingPattern,
-                          const ReductionLoopMap &reductionLoops) {
+void mlir::affine::vectorizeAffineLoops(
+    Operation *parentOp, DenseSet<Operation *> &loops,
+    ArrayRef<int64_t> vectorSizes, ArrayRef<int64_t> fastestVaryingPattern,
   // Thread-safe RAII local context, BumpPtrAllocator freed on exit.
   NestedPatternContext mlContext;
   vectorizeLoops(parentOp, loops, vectorSizes, fastestVaryingPattern,
                  reductionLoops);
 }
 
 /// External utility to vectorize affine loops from a single loop nest using an
 /// n-D vectorization strategy (see doc in VectorizationStrategy definition).

 ///
 /// loops = {{%i0}, {%i2, %i3}}, to vectorize the outermost and the two
 /// innermost loops;
 /// loops = {{%i1}, {%i2, %i3}}, to vectorize the middle and the two innermost
 /// loops;
 /// loops = {{%i2}}, to vectorize only the first innermost loop;
 /// loops = {{%i3}}, to vectorize only the second innermost loop;
 /// loops = {{%i1}}, to vectorize only the middle loop.
-LogicalResult
-vectorizeAffineLoopNest(std::vector<SmallVector<AffineForOp, 2>> &loops,
-                        const VectorizationStrategy &strategy) {
+LogicalResult mlir::affine::vectorizeAffineLoopNest(
+    std::vector<SmallVector<AffineForOp, 2>> &loops,
   // Thread-safe RAII local context, BumpPtrAllocator freed on exit.
   NestedPatternContext mlContext;
   if (failed(verifyLoopNesting(loops)))
     return failure();
   return vectorizeLoopNest(loops, strategy);
 }
-
-} // namespace mlir

mlir/lib/Dialect/Affine/Utils/LoopFusionUtils.cpp

 #include "mlir/IR/Operation.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 #define DEBUG_TYPE "loop-fusion-utils"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 // Gathers all load and store memref accesses in 'opA' into 'values', where
 // 'values[memref] == true' for each store operation.
 static void getLoadAndStoreMemRefAccesses(Operation *opA,
                                           DenseMap<Value, bool> &values) {
   opA->walk([&](Operation *op) {
     if (auto loadOp = dyn_cast<AffineReadOpInterface>(op)) {
       if (values.count(loadOp.getMemRef()) == 0)
static unsigned getMaxLoopDepth(ArrayRef<Operation *> srcOps,
 
   return loopDepth;
 }
 
 // TODO: Prevent fusion of loop nests with side-effecting operations.
 // TODO: This pass performs some computation that is the same for all the depths
 // (e.g., getMaxLoopDepth). Implement a version of this utility that processes
 // all the depths at once or only the legal maximal depth for maximal fusion.
-FusionResult mlir::canFuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,
+FusionResult mlir::affine::canFuseLoops(AffineForOp srcForOp,
+                                        AffineForOp dstForOp,
                                         unsigned dstLoopDepth,
                                         ComputationSliceState *srcSlice,
                                         FusionStrategy fusionStrategy) {
   // Return 'failure' if 'dstLoopDepth == 0'.
   if (dstLoopDepth == 0) {
     LLVM_DEBUG(llvm::dbgs() << "Cannot fuse loop nests at depth 0\n");
     return FusionResult::FailPrecondition;
   }
   // Return 'failure' if 'srcForOp' and 'dstForOp' are not in the same block.
   auto *block = srcForOp->getBlock();
   if (block != dstForOp->getBlock()) {
if (fusionStrategy.getStrategy() == FusionStrategy::ProducerConsumer) {
     if (getMaxLoopDepth(opsA, opsB) < dstLoopDepth) {
       LLVM_DEBUG(llvm::dbgs() << "Fusion would violate loop dependences\n");
       return FusionResult::FailFusionDependence;
     }
   }
 
   // Calculate the number of common loops surrounding 'srcForOp' and 'dstForOp'.
   unsigned numCommonLoops =
-      mlir::getNumCommonSurroundingLoops(*srcForOp, *dstForOp);
+      affine::getNumCommonSurroundingLoops(*srcForOp, *dstForOp);
 
   // Filter out ops in 'opsA' to compute the slice union based on the
   // assumptions made by the fusion strategy.
   SmallVector<Operation *, 4> strategyOpsA;
   switch (fusionStrategy.getStrategy()) {
   case FusionStrategy::Generic:
     // Generic fusion. Take into account all the memory operations to compute
     // the slice union.
for (Operation *op : opsA) {
       if (load && load.getMemRef() == fusionStrategy.getSiblingFusionMemRef())
         strategyOpsA.push_back(op);
     }
     break;
   }
 
   // Compute union of computation slices computed between all pairs of ops
   // from 'forOpA' and 'forOpB'.
-  SliceComputationResult sliceComputationResult =
-      mlir::computeSliceUnion(strategyOpsA, opsB, dstLoopDepth, numCommonLoops,
-                              isSrcForOpBeforeDstForOp, srcSlice);
+  SliceComputationResult sliceComputationResult = affine::computeSliceUnion(
+      strategyOpsA, opsB, dstLoopDepth, numCommonLoops,
   if (sliceComputationResult.value == SliceComputationResult::GenericFailure) {
     LLVM_DEBUG(llvm::dbgs() << "computeSliceUnion failed\n");
     return FusionResult::FailPrecondition;
   }
   if (sliceComputationResult.value ==
       SliceComputationResult::IncorrectSliceFailure) {
     LLVM_DEBUG(llvm::dbgs() << "Incorrect slice computation\n");
     return FusionResult::FailIncorrectSlice;
   }
 
   return FusionResult::Success;
 }
 
 /// Patch the loop body of a forOp that is a single iteration reduction loop
 /// into its containing block.
-LogicalResult promoteSingleIterReductionLoop(AffineForOp forOp,
+static LogicalResult promoteSingleIterReductionLoop(AffineForOp forOp,
                                                     bool siblingFusionUser) {
   // Check if the reduction loop is a single iteration loop.
   std::optional<uint64_t> tripCount = getConstantTripCount(forOp);
   if (!tripCount || *tripCount != 1)
     return failure();
   auto iterOperands = forOp.getIterOperands();
   auto *parentOp = forOp->getParentOp();
   if (!isa<AffineForOp>(parentOp))
     return failure();
parentBlock->getOperations().splice(Block::iterator(forOp),
                                       forOp.getBody()->getOperations());
   forOp.erase();
   parentForOp.erase();
   return success();
 }
 
 /// Fuses 'srcForOp' into 'dstForOp' with destination loop block insertion point
 /// and source slice loop bounds specified in 'srcSlice'.
-void mlir::fuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,
+void mlir::affine::fuseLoops(AffineForOp srcForOp, AffineForOp dstForOp,
                              const ComputationSliceState &srcSlice,
                              bool isInnermostSiblingInsertion) {
   // Clone 'srcForOp' into 'dstForOp' at 'srcSlice->insertPoint'.
   OpBuilder b(srcSlice.insertPoint->getBlock(), srcSlice.insertPoint);
   IRMapping mapper;
   b.clone(*srcForOp, mapper);
 
   // Update 'sliceLoopNest' upper and lower bounds from computed 'srcSlice'.
   SmallVector<AffineForOp, 4> sliceLoops;
   for (unsigned i = 0, e = srcSlice.ivs.size(); i < e; ++i) {
else
       // Promote any single iteration slice loops.
       (void)promoteIfSingleIteration(forOp);
   }
 }
 
 /// Collect loop nest statistics (eg. loop trip count and operation count)
 /// in 'stats' for loop nest rooted at 'forOp'. Returns true on success,
 /// returns false otherwise.
-bool mlir::getLoopNestStats(AffineForOp forOpRoot, LoopNestStats *stats) {
+bool mlir::affine::getLoopNestStats(AffineForOp forOpRoot,
+                                    LoopNestStats *stats) {
   auto walkResult = forOpRoot.walk([&](AffineForOp forOp) {
     auto *childForOp = forOp.getOperation();
     auto *parentForOp = forOp->getParentOp();
     if (forOp != forOpRoot) {
       if (!isa<AffineForOp>(parentForOp)) {
         LLVM_DEBUG(llvm::dbgs() << "Expected parent AffineForOp\n");
         return WalkResult::interrupt();
       }
static int64_t getComputeCostHelper(
   // Returns the total number of dynamic instances of operations in loop body.
   return tripCount * opCount;
 }
 
 /// Computes the total cost of the loop nest rooted at 'forOp' using 'stats'.
 /// Currently, the total cost is computed by counting the total operation
 /// instance count (i.e. total number of operations in the loop body * loop
 /// trip count) for the entire loop nest.
-int64_t mlir::getComputeCost(AffineForOp forOp, LoopNestStats &stats) {
+int64_t mlir::affine::getComputeCost(AffineForOp forOp, LoopNestStats &stats) {
   return getComputeCostHelper(forOp, stats,
                               /*tripCountOverrideMap=*/nullptr,
                               /*computeCostMap=*/nullptr);
 }
 
 /// Computes and returns in 'computeCost', the total compute cost of fusing the
 /// 'slice' of the loop nest rooted at 'srcForOp' into 'dstForOp'. Currently,
 /// the total cost is computed by counting the total operation instance count
 /// (i.e. total number of operations in the loop body * loop trip count) for
 /// the entire loop nest.
-bool mlir::getFusionComputeCost(AffineForOp srcForOp, LoopNestStats &srcStats,
-                                AffineForOp dstForOp, LoopNestStats &dstStats,
+bool mlir::affine::getFusionComputeCost(AffineForOp srcForOp,
+                                        LoopNestStats &srcStats,
+                                        AffineForOp dstForOp,
+                                        LoopNestStats &dstStats,
                                         const ComputationSliceState &slice,
                                         int64_t *computeCost) {
   llvm::SmallDenseMap<Operation *, uint64_t, 8> sliceTripCountMap;
   DenseMap<Operation *, int64_t> computeCostMap;
 
   // Build trip count map for computation slice.
   if (!buildSliceTripCountMap(slice, &sliceTripCountMap))
     return false;
   // Checks whether a store to load forwarding will happen.
   int64_t sliceIterationCount = getSliceIterationCount(sliceTripCountMap);
*computeCost =
       getComputeCostHelper(dstForOp, dstStats,
                            /*tripCountOverrideMap=*/nullptr, &computeCostMap);
   return true;
 }
 
 /// Returns in 'producerConsumerMemrefs' the memrefs involved in a
 /// producer-consumer dependence between write ops in 'srcOps' and read ops in
 /// 'dstOps'.
-void mlir::gatherProducerConsumerMemrefs(
+void mlir::affine::gatherProducerConsumerMemrefs(
     ArrayRef<Operation *> srcOps, ArrayRef<Operation *> dstOps,
     DenseSet<Value> &producerConsumerMemrefs) {
   // Gather memrefs from stores in 'srcOps'.
   DenseSet<Value> srcStoreMemRefs;
   for (Operation *op : srcOps)
     if (auto storeOp = dyn_cast<AffineWriteOpInterface>(op))
       srcStoreMemRefs.insert(storeOp.getMemRef());
 
   // Compute the intersection between memrefs from stores in 'srcOps' and
   // memrefs from loads in 'dstOps'.
   for (Operation *op : dstOps)
     if (auto loadOp = dyn_cast<AffineReadOpInterface>(op))
       if (srcStoreMemRefs.count(loadOp.getMemRef()) > 0)
         producerConsumerMemrefs.insert(loadOp.getMemRef());
 }

mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 #define DEBUG_TYPE "loop-utils"
 
 using namespace mlir;
+using namespace affine;
 using namespace presburger;
 using llvm::SmallMapVector;
 
 namespace {
 // This structure is to pass and return sets of loop parameters without
 // confusing the order.
 struct LoopParams {
   Value lowerBound;
static void replaceIterArgsAndYieldResults(AffineForOp forOp) {
   auto innerResults = forOp.getBody()->getTerminator()->getOperands();
   for (auto e : llvm::zip(outerResults, innerResults))
     std::get<0>(e).replaceAllUsesWith(std::get<1>(e));
 }
 
 /// Promotes the loop body of a forOp to its containing block if the forOp
 /// was known to have a single iteration.
 // TODO: extend this for arbitrary affine bounds.
-LogicalResult mlir::promoteIfSingleIteration(AffineForOp forOp) {
+LogicalResult mlir::affine::promoteIfSingleIteration(AffineForOp forOp) {
   std::optional<uint64_t> tripCount = getConstantTripCount(forOp);
   if (!tripCount || *tripCount != 1)
     return failure();
 
   if (forOp.getLowerBoundMap().getNumResults() != 1)
     return failure();
 
   // Replaces all IV uses to its single iteration value.

 // for better register reuse, locality or parallelism. As such, the shifts are
 // typically expected to be at most of the order of the number of operations.
 // This method should not be used as a substitute for loop distribution/fission.
 // This method uses an algorithm// in time linear in the number of operations
 // in the body of the for loop - (using the 'sweep line' paradigm). This method
 // asserts preservation of SSA dominance. A check for that as well as that for
 // memory-based dependence preservation check rests with the users of this
 // method.
-LogicalResult mlir::affineForOpBodySkew(AffineForOp forOp,
+LogicalResult mlir::affine::affineForOpBodySkew(AffineForOp forOp,
                                                 ArrayRef<uint64_t> shifts,
                                                 bool unrollPrologueEpilogue) {
   assert(forOp.getBody()->getOperations().size() == shifts.size() &&
          "too few/many shifts");
   if (forOp.getBody()->begin() == std::prev(forOp.getBody()->end()))
     return success();
 
   // If the trip counts aren't constant, we would need versioning and
   // conditional guards (or context information to prevent such versioning). The
   // better way to pipeline for such loops is to first tile them and extract
if (unrollPrologueEpilogue && prologue)
     (void)loopUnrollFull(prologue);
   if (unrollPrologueEpilogue && !epilogue && epilogue != prologue)
     (void)loopUnrollFull(epilogue);
 
   return success();
 }
 
 /// Checks whether a loop nest is hyper-rectangular or not.
-LogicalResult checkIfHyperRectangular(MutableArrayRef<AffineForOp> input) {
+static LogicalResult
+checkIfHyperRectangular(MutableArrayRef<AffineForOp> input) {
   FlatAffineValueConstraints cst;
   SmallVector<Operation *, 8> ops(input.begin(), input.end());
   // 0-d or 1-d is trivially hyper-rectangular.
   if (input.size() <= 1)
     return success();
   if (failed(getIndexSet(ops, &cst))) {
     LLVM_DEBUG(llvm::dbgs() << "Index set computation failed!\n");
     return failure();
   }
   if (!cst.isHyperRectangular(0, input.size())) {
     LLVM_DEBUG(llvm::dbgs()
                << "Non-hyperrectangular nests not supported for tiling!\n");
     return failure();
   }
   return success();
 }
 
 /// Check if the input nest is supported for tiling and whether tiling would be
 /// legal or not.
 template <typename t>
-LogicalResult performPreTilingChecks(MutableArrayRef<AffineForOp> input,
+static LogicalResult performPreTilingChecks(MutableArrayRef<AffineForOp> input,
                                             ArrayRef<t> tileSizes) {
   assert(input.size() == tileSizes.size() && "Too few/many tile sizes");
 
   if (llvm::any_of(input,
                    [](AffineForOp op) { return op.getNumResults() > 0; })) {
     LLVM_DEBUG(llvm::dbgs()
                << "Cannot tile nest where a loop has yield values\n");
     return failure();
   }
static void moveLoopBodyImpl(AffineForOp src, AffineForOp dest,
                              Block::iterator loc) {
   auto &ops = src.getBody()->getOperations();
   dest.getBody()->getOperations().splice(loc, ops, ops.begin(),
                                          std::prev(ops.end()));
 }
 
 /// Move the loop body of AffineForOp 'src' from 'src' to the start of dest
 /// body.
-void moveLoopBody(AffineForOp src, AffineForOp dest) {
+static void moveLoopBody(AffineForOp src, AffineForOp dest) {
   moveLoopBodyImpl(src, dest, dest.getBody()->begin());
 }
 
 /// Constructs tiled loop nest, without setting the loop bounds and move the
 /// body of the original loop nest to the tiled loop nest.
-void constructTiledLoopNest(MutableArrayRef<AffineForOp> origLoops,
+static void constructTiledLoopNest(MutableArrayRef<AffineForOp> origLoops,
                                    AffineForOp rootAffineForOp, unsigned width,
                                    MutableArrayRef<AffineForOp> tiledLoops) {
   Location loc = rootAffineForOp.getLoc();
 
   // The outermost among the loops as we add more..
   Operation *topLoop = rootAffineForOp.getOperation();
   AffineForOp innermostPointLoop;
 
   // Add intra-tile (or point) loops.
   for (unsigned i = 0; i < width; i++) {
if (mayBeConstantCount && *mayBeConstantCount < tileSizes[i]) {
       AffineMap ubMap =
           AffineMap::get(1, 0, dim + tileSizes[i] * origLoops[i].getStep());
       newLoops[width + i].setUpperBound(newLoops[i].getInductionVar(), ubMap);
     }
   }
 }
 
 LogicalResult
-mlir::tilePerfectlyNested(MutableArrayRef<AffineForOp> input,
+mlir::affine::tilePerfectlyNested(MutableArrayRef<AffineForOp> input,
                                   ArrayRef<unsigned> tileSizes,
                                   SmallVectorImpl<AffineForOp> *tiledNest) {
   if (input.empty())
     return success();
 
   if (failed(performPreTilingChecks(input, tileSizes)))
     return failure();
 
   MutableArrayRef<AffineForOp> origLoops = input;
   AffineForOp rootAffineForOp = origLoops[0];
mlir::affine::tilePerfectlyNested(MutableArrayRef<AffineForOp> input,
 
   return success();
 }
 
 /// Tiles the specified band of perfectly nested loops creating tile-space
 /// loops and intra-tile loops, using SSA values as tiling parameters. A band
 /// is a contiguous set of loops.
 //  TODO: handle non hyper-rectangular spaces.
-LogicalResult
-mlir::tilePerfectlyNestedParametric(MutableArrayRef<AffineForOp> input,
-                                    ArrayRef<Value> tileSizes,
-                                    SmallVectorImpl<AffineForOp> *tiledNest) {
+LogicalResult mlir::affine::tilePerfectlyNestedParametric(
+    MutableArrayRef<AffineForOp> input, ArrayRef<Value> tileSizes,
   if (input.empty())
     return success();
 
   if (failed(performPreTilingChecks(input, tileSizes)))
     return failure();
 
   MutableArrayRef<AffineForOp> origLoops = input;
   AffineForOp rootAffineForOp = origLoops[0];
LogicalResult mlir::affine::tilePerfectlyNestedParametric(
 
   return success();
 }
 
 /// Get perfectly nested sequence of loops starting at root of loop nest
 /// (the first op being another AffineFor, and the second op - a terminator).
 /// A loop is perfectly nested iff: the first op in the loop's body is another
 /// AffineForOp, and the second op is a terminator).
-void mlir::getPerfectlyNestedLoops(SmallVectorImpl<AffineForOp> &nestedLoops,
-                                   AffineForOp root) {
+void mlir::affine::getPerfectlyNestedLoops(
+    SmallVectorImpl<AffineForOp> &nestedLoops, AffineForOp root) {
   for (unsigned i = 0; i < std::numeric_limits<unsigned>::max(); ++i) {
     nestedLoops.push_back(root);
     Block &body = root.getRegion().front();
     if (body.begin() != std::prev(body.end(), 2))
       return;
 
     root = dyn_cast<AffineForOp>(&body.front());
     if (!root)
       return;
   }
 }
 
 /// Identify valid and profitable bands of loops to tile. This is currently just
 /// a temporary placeholder to test the mechanics of tiled code generation.
 /// Returns all maximal outermost perfect loop nests to tile.
-void mlir::getTileableBands(func::FuncOp f,
-                            std::vector<SmallVector<AffineForOp, 6>> *bands) {
+void mlir::affine::getTileableBands(
+    func::FuncOp f, std::vector<SmallVector<AffineForOp, 6>> *bands) {
   // Get maximal perfect nest of 'affine.for' insts starting from root
   // (inclusive).
   for (AffineForOp forOp : f.getOps<AffineForOp>()) {
     SmallVector<AffineForOp, 6> band;
     getPerfectlyNestedLoops(band, forOp);
     bands->push_back(band);
   }
 }
 
 /// Unrolls this loop completely.
-LogicalResult mlir::loopUnrollFull(AffineForOp forOp) {
+LogicalResult mlir::affine::loopUnrollFull(AffineForOp forOp) {
   std::optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (mayBeConstantTripCount.has_value()) {
     uint64_t tripCount = *mayBeConstantTripCount;
     if (tripCount == 0)
       return success();
     if (tripCount == 1)
       return promoteIfSingleIteration(forOp);
     return loopUnrollByFactor(forOp, tripCount);
   }
   return failure();
 }
 
 /// Unrolls this loop by the specified factor or by the trip count (if constant)
 /// whichever is lower.
-LogicalResult mlir::loopUnrollUpToFactor(AffineForOp forOp,
+LogicalResult mlir::affine::loopUnrollUpToFactor(AffineForOp forOp,
                                                  uint64_t unrollFactor) {
   std::optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (mayBeConstantTripCount.has_value() &&
       *mayBeConstantTripCount < unrollFactor)
     return loopUnrollByFactor(forOp, *mayBeConstantTripCount);
   return loopUnrollByFactor(forOp, unrollFactor);
 }
 
 /// Generates unrolled copies of AffineForOp 'loopBodyBlock', with associated
static LogicalResult generateCleanupLoopForUnroll(AffineForOp forOp,
   // Adjust upper bound of the original loop; this is the same as the lower
   // bound of the cleanup loop.
   forOp.setUpperBound(cleanupOperands, cleanupMap);
   return success();
 }
 
 /// Unrolls this loop by the specified factor. Returns success if the loop
 /// is successfully unrolled.
-LogicalResult mlir::loopUnrollByFactor(
+LogicalResult mlir::affine::loopUnrollByFactor(
     AffineForOp forOp, uint64_t unrollFactor,
     function_ref<void(unsigned, Operation *, OpBuilder)> annotateFn,
     bool cleanUpUnroll) {
   assert(unrollFactor > 0 && "unroll factor should be positive");
 
   std::optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (unrollFactor == 1) {
     if (mayBeConstantTripCount && *mayBeConstantTripCount == 1 &&
generateUnrolledLoop(
       /*annotateFn=*/annotateFn,
       /*iterArgs=*/iterArgs, /*yieldedValues=*/yieldedValues);
 
   // Promote the loop body up if this has turned into a single iteration loop.
   (void)promoteIfSingleIteration(forOp);
   return success();
 }
 
-LogicalResult mlir::loopUnrollJamUpToFactor(AffineForOp forOp,
+LogicalResult mlir::affine::loopUnrollJamUpToFactor(AffineForOp forOp,
                                                     uint64_t unrollJamFactor) {
   std::optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (mayBeConstantTripCount.has_value() &&
       *mayBeConstantTripCount < unrollJamFactor)
     return loopUnrollJamByFactor(forOp, *mayBeConstantTripCount);
   return loopUnrollJamByFactor(forOp, unrollJamFactor);
 }
 
 /// Check if all control operands of all loops are defined outside of `forOp`
for (auto it = block.begin(), e = std::prev(block.end()); it != e;) {
       // Process all for ops that appear next.
       while (it != e && isa<AffineForOp>(&*it))
         walk(&*it++);
     }
   }
 };
 
 /// Unrolls and jams this loop by the specified factor.
-LogicalResult mlir::loopUnrollJamByFactor(AffineForOp forOp,
+LogicalResult mlir::affine::loopUnrollJamByFactor(AffineForOp forOp,
                                                   uint64_t unrollJamFactor) {
   assert(unrollJamFactor > 0 && "unroll jam factor should be positive");
 
   std::optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp);
   if (unrollJamFactor == 1) {
     if (mayBeConstantTripCount && *mayBeConstantTripCount == 1 &&
         failed(promoteIfSingleIteration(forOp)))
       return failure();
     return success();
for (AffineForOp oldForOp : loopsWithIterArgs) {
     // fix iterOperands and yield operands after cloning of sub-blocks.
     for (unsigned i = unrollJamFactor - 1; i >= 1; --i) {
       dupIterOperands.append(oldIterOperands.begin(), oldIterOperands.end());
       dupIterArgs.append(oldIterArgs.begin(), oldIterArgs.end());
       dupYieldOperands.append(oldYieldOperands.begin(), oldYieldOperands.end());
     }
     // Create a new loop with additional iterOperands, iter_args and yield
     // operands. This new loop will take the loop body of the original loop.
-    AffineForOp newForOp = mlir::replaceForOpWithNewYields(
+    AffineForOp newForOp = affine::replaceForOpWithNewYields(
         builder, oldForOp, dupIterOperands, dupYieldOperands, dupIterArgs);
     newLoopsWithIterArgs.push_back(newForOp);
     // `forOp` has been replaced with a new loop.
     if (oldForOp == forOp)
       forOp = newForOp;
     assert(oldForOp.use_empty() && "old for op should not have any user");
     oldForOp.erase();
     // Update `operandMaps` for `newForOp` iterArgs and results.
LogicalResult mlir::affine::loopUnrollJamByFactor(AffineForOp forOp,
 
   // Promote the loop body up if this has turned into a single iteration loop.
   (void)promoteIfSingleIteration(forOp);
   return success();
 }
 
 /// Performs loop interchange on 'forOpA' and 'forOpB', where 'forOpB' is
 /// nested within 'forOpA' as the only non-terminator operation in its block.
-void mlir::interchangeLoops(AffineForOp forOpA, AffineForOp forOpB) {
+void mlir::affine::interchangeLoops(AffineForOp forOpA, AffineForOp forOpB) {
   assert(&*forOpA.getBody()->begin() == forOpB.getOperation());
   auto &forOpABody = forOpA.getBody()->getOperations();
   auto &forOpBBody = forOpB.getBody()->getOperations();
 
   // 1) Splice forOpA's non-terminator operations (which is just forOpB) just
   // before forOpA (in ForOpA's parent's block) this should leave 'forOpA's
   // body containing only the terminator.
   forOpA->getBlock()->getOperations().splice(Block::iterator(forOpA),
for (unsigned j = 0; j < maxLoopDepth; ++j) {
         return false;
     }
   }
   return true;
 }
 
 /// Checks if the loop interchange permutation 'loopPermMap' of the perfectly
 /// nested sequence of loops in 'loops' would violate dependences.
-bool mlir::isValidLoopInterchangePermutation(ArrayRef<AffineForOp> loops,
-                                             ArrayRef<unsigned> loopPermMap) {
+bool mlir::affine::isValidLoopInterchangePermutation(
+    ArrayRef<AffineForOp> loops, ArrayRef<unsigned> loopPermMap) {
   // Gather dependence components for dependences between all ops in loop nest
   // rooted at 'loops[0]', at loop depths in range [1, maxLoopDepth].
   assert(loopPermMap.size() == loops.size());
   unsigned maxLoopDepth = loops.size();
   std::vector<SmallVector<DependenceComponent, 2>> depCompsVec;
   getDependenceComponents(loops[0], maxLoopDepth, &depCompsVec);
   return checkLoopInterchangeDependences(depCompsVec, loops, loopPermMap);
 }
 
 /// Returns true if `loops` is a perfectly nested loop nest, where loops appear
 /// in it from outermost to innermost.
 bool LLVM_ATTRIBUTE_UNUSED
-mlir::isPerfectlyNested(ArrayRef<AffineForOp> loops) {
+mlir::affine::isPerfectlyNested(ArrayRef<AffineForOp> loops) {
   assert(!loops.empty() && "no loops provided");
 
   // We already know that the block can't be empty.
   auto hasTwoElements = [](Block *block) {
     auto secondOpIt = std::next(block->begin());
     return secondOpIt != block->end() && &*secondOpIt == &block->back();
   };
 
   auto enclosingLoop = loops.front();
   for (auto loop : loops.drop_front()) {
     auto parentForOp = dyn_cast<AffineForOp>(loop->getParentOp());
     // parentForOp's body should be just this loop and the terminator.
     if (parentForOp != enclosingLoop || !hasTwoElements(parentForOp.getBody()))
       return false;
     enclosingLoop = loop;
   }
   return true;
 }
 
 // input[i] should move from position i -> permMap[i]. Returns the position in
 // `input` that becomes the new outermost loop.
-unsigned mlir::permuteLoops(MutableArrayRef<AffineForOp> input,
+unsigned mlir::affine::permuteLoops(MutableArrayRef<AffineForOp> input,
                                     ArrayRef<unsigned> permMap) {
   assert(input.size() == permMap.size() && "invalid permutation map size");
   // Check whether the permutation spec is valid. This is a small vector - we'll
   // just sort and check if it's iota.
   SmallVector<unsigned, 4> checkPermMap(permMap.begin(), permMap.end());
   llvm::sort(checkPermMap);
   if (llvm::any_of(llvm::enumerate(checkPermMap),
                    [](const auto &en) { return en.value() != en.index(); }))
     assert(false && "invalid permutation map");
unsigned mlir::affine::permuteLoops(MutableArrayRef<AffineForOp> input,
   }
 
   return invPermMap[0].second;
 }
 
 // Sinks all sequential loops to the innermost levels (while preserving
 // relative order among them) and moves all parallel loops to the
 // outermost (while again preserving relative order among them).
-AffineForOp mlir::sinkSequentialLoops(AffineForOp forOp) {
+AffineForOp mlir::affine::sinkSequentialLoops(AffineForOp forOp) {
   SmallVector<AffineForOp, 4> loops;
   getPerfectlyNestedLoops(loops, forOp);
   if (loops.size() < 2)
     return forOp;
 
   // Gather dependence components for dependences between all ops in loop nest
   // rooted at 'loops[0]', at loop depths in range [1, maxLoopDepth].
   unsigned maxLoopDepth = loops.size();
static AffineForOp stripmineSink(AffineForOp forOp, SizeType factor,
   // exposes the capability. It seems overkill to construct a whole function
   // dominance tree at this point.
   auto res = stripmineSink(forOp, factor, ArrayRef<AffineForOp>(target));
   assert(res.size() == 1 && "Expected 1 inner forOp");
   return res[0];
 }
 
 SmallVector<SmallVector<AffineForOp, 8>, 8>
-mlir::tile(ArrayRef<AffineForOp> forOps, ArrayRef<uint64_t> sizes,
+mlir::affine::tile(ArrayRef<AffineForOp> forOps, ArrayRef<uint64_t> sizes,
                    ArrayRef<AffineForOp> targets) {
   SmallVector<SmallVector<AffineForOp, 8>, 8> res;
   SmallVector<AffineForOp, 8> currentTargets(targets.begin(), targets.end());
   for (auto it : llvm::zip(forOps, sizes)) {
     auto step = stripmineSink(std::get<0>(it), std::get<1>(it), currentTargets);
     res.push_back(step);
     currentTargets = step;
   }
   return res;
 }
 
-SmallVector<AffineForOp, 8> mlir::tile(ArrayRef<AffineForOp> forOps,
+SmallVector<AffineForOp, 8> mlir::affine::tile(ArrayRef<AffineForOp> forOps,
                                                ArrayRef<uint64_t> sizes,
                                                AffineForOp target) {
   SmallVector<AffineForOp, 8> res;
   for (auto loops : tile(forOps, sizes, ArrayRef<AffineForOp>(target))) {
     assert(loops.size() == 1);
     res.push_back(loops[0]);
   }
   return res;
 }
 
-LogicalResult mlir::coalesceLoops(MutableArrayRef<AffineForOp> loops) {
+LogicalResult mlir::affine::coalesceLoops(MutableArrayRef<AffineForOp> loops) {
   if (loops.size() < 2)
     return success();
 
   AffineForOp innermost = loops.back();
   AffineForOp outermost = loops.front();
   AffineBound ub = outermost.getUpperBound();
   AffineMap origUbMap = ub.getMap();
   Location loc = outermost.getLoc();
LogicalResult mlir::affine::coalesceLoops(MutableArrayRef<AffineForOp> loops) {
   innermost.getBody()->back().erase();
   outermost.getBody()->getOperations().splice(
       Block::iterator(secondOutermostLoop.getOperation()),
       innermost.getBody()->getOperations());
   secondOutermostLoop.erase();
   return success();
 }
 
-void mlir::mapLoopToProcessorIds(scf::ForOp forOp, ArrayRef<Value> processorId,
+void mlir::affine::mapLoopToProcessorIds(scf::ForOp forOp,
+                                         ArrayRef<Value> processorId,
                                          ArrayRef<Value> numProcessors) {
   assert(processorId.size() == numProcessors.size());
   if (processorId.empty())
     return;
 
   OpBuilder b(forOp);
   Location loc(forOp.getLoc());
   AffineExpr lhs, rhs;
   bindSymbols(forOp.getContext(), lhs, rhs);
for (unsigned d = 0; d < rank; d++) {
     auto dimSize = memRefType.getDimSize(d);
     assert(dimSize > 0 && "filtered dynamic shapes above");
     regionCst->addBound(BoundType::LB, d, 0);
     regionCst->addBound(BoundType::UB, d, dimSize - 1);
   }
   return true;
 }
 
-LogicalResult mlir::affineDataCopyGenerate(Block::iterator begin,
-                                           Block::iterator end,
-                                           const AffineCopyOptions &copyOptions,
-                                           std::optional<Value> filterMemRef,
-                                           DenseSet<Operation *> &copyNests) {
+LogicalResult
+mlir::affine::affineDataCopyGenerate(Block::iterator begin, Block::iterator end,
   if (begin == end)
     return success();
 
   assert(begin->getBlock() == std::prev(end)->getBlock() &&
          "Inconsistent block begin/end args");
   assert(end != end->getBlock()->end() && "end can't be the block terminator");
 
   Block *block = begin->getBlock();
block->getParentOp()->emitWarning(
         "capacity");
   }
 
   return success();
 }
 
 // A convenience version of affineDataCopyGenerate for all ops in the body of
 // an AffineForOp.
-LogicalResult mlir::affineDataCopyGenerate(AffineForOp forOp,
-                                           const AffineCopyOptions &copyOptions,
-                                           std::optional<Value> filterMemRef,
-                                           DenseSet<Operation *> &copyNests) {
+LogicalResult mlir::affine::affineDataCopyGenerate(
+    AffineForOp forOp, const AffineCopyOptions &copyOptions,
+    std::optional<Value> filterMemRef, DenseSet<Operation *> &copyNests) {
   return affineDataCopyGenerate(forOp.getBody()->begin(),
                                 std::prev(forOp.getBody()->end()), copyOptions,
                                 filterMemRef, copyNests);
 }
 
-LogicalResult mlir::generateCopyForMemRegion(
+LogicalResult mlir::affine::generateCopyForMemRegion(
     const MemRefRegion &memrefRegion, Operation *analyzedOp,
     const AffineCopyOptions &copyOptions, CopyGenerateResult &result) {
   Block *block = analyzedOp->getBlock();
   auto begin = analyzedOp->getIterator();
   auto end = std::next(begin);
   DenseMap<Value, Value> fastBufferMap;
   DenseSet<Operation *> copyNests;
 
for (auto &op : *block) {
     if (auto forOp = dyn_cast<AffineForOp>(op)) {
       depthToLoops[currLoopDepth].push_back(forOp);
       gatherLoopsInBlock(forOp.getBody(), currLoopDepth + 1, depthToLoops);
     }
   }
 }
 
 /// Gathers all AffineForOps in 'func.func' grouped by loop depth.
-void mlir::gatherLoops(func::FuncOp func,
-                       std::vector<SmallVector<AffineForOp, 2>> &depthToLoops) {
+void mlir::affine::gatherLoops(
+    func::FuncOp func, std::vector<SmallVector<AffineForOp, 2>> &depthToLoops) {
   for (auto &block : func)
     gatherLoopsInBlock(&block, /*currLoopDepth=*/0, depthToLoops);
 
   // Remove last loop level from output since it's empty.
   if (!depthToLoops.empty()) {
     assert(depthToLoops.back().empty() && "Last loop level is not empty?");
     depthToLoops.pop_back();
   }
 }
 
 // TODO: if necessary, this can be extended to also compose in any
 // affine.applys, fold to constant if all result dimensions of the map are
 // constant (canonicalizeMapAndOperands below already does this for single
 // result bound maps), and use simplifyMap to perform algebraic simplification.
-AffineForOp mlir::createCanonicalizedAffineForOp(
+AffineForOp mlir::affine::createCanonicalizedAffineForOp(
     OpBuilder b, Location loc, ValueRange lbOperands, AffineMap lbMap,
     ValueRange ubOperands, AffineMap ubMap, int64_t step) {
   SmallVector<Value, 4> lowerOperands(lbOperands);
   SmallVector<Value, 4> upperOperands(ubOperands);
 
   fullyComposeAffineMapAndOperands(&lbMap, &lowerOperands);
   canonicalizeMapAndOperands(&lbMap, &lowerOperands);
   lbMap = removeDuplicateExprs(lbMap);
operandMap.map(loopEn.value().getInductionVar(),
                    fullTileLoops[loopEn.index()].getInductionVar());
   b = OpBuilder::atBlockTerminator(fullTileLoops.back().getBody());
   for (auto &op : inputNest.back().getBody()->without_terminator())
     b.clone(op, operandMap);
   return success();
 }
 
 LogicalResult
-mlir::separateFullTiles(MutableArrayRef<AffineForOp> inputNest,
+mlir::affine::separateFullTiles(MutableArrayRef<AffineForOp> inputNest,
                                 SmallVectorImpl<AffineForOp> *fullTileNest) {
   if (inputNest.empty())
     return success();
 
   auto firstLoop = inputNest[0];
 
   // Each successive for op has to be nested in the other.
   auto prevLoop = firstLoop;
   for (auto loop : inputNest.drop_front(1)) {

mlir/lib/Dialect/Affine/Utils/Utils.cpp

 #include "mlir/IR/IRMapping.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include <optional>
 
 #define DEBUG_TYPE "affine-utils"
 
 using namespace mlir;
+using namespace affine;
 using namespace presburger;
 
 namespace {
 /// Visit affine expressions recursively and build the sequence of operations
 /// that correspond to it.  Visitation functions return an Value of the
 /// expression subtree they visited or `nullptr` on error.
 class AffineApplyExpander
     : public AffineExprVisitor<AffineApplyExpander, Value> {
private:
   ValueRange symbolValues;
 
   Location loc;
 };
 } // namespace
 
 /// Create a sequence of operations that implement the `expr` applied to the
 /// given dimension and symbol values.
-mlir::Value mlir::expandAffineExpr(OpBuilder &builder, Location loc,
-                                   AffineExpr expr, ValueRange dimValues,
+mlir::Value mlir::affine::expandAffineExpr(OpBuilder &builder, Location loc,
+                                           AffineExpr expr,
+                                           ValueRange dimValues,
                                            ValueRange symbolValues) {
   return AffineApplyExpander(builder, dimValues, symbolValues, loc).visit(expr);
 }
 
 /// Create a sequence of operations that implement the `affineMap` applied to
 /// the given `operands` (as it it were an AffineApplyOp).
 std::optional<SmallVector<Value, 8>>
-mlir::expandAffineMap(OpBuilder &builder, Location loc, AffineMap affineMap,
-                      ValueRange operands) {
+mlir::affine::expandAffineMap(OpBuilder &builder, Location loc,
+                              AffineMap affineMap, ValueRange operands) {
   auto numDims = affineMap.getNumDims();
   auto expanded = llvm::to_vector<8>(
       llvm::map_range(affineMap.getResults(),
                       [numDims, &builder, loc, operands](AffineExpr expr) {
                         return expandAffineExpr(builder, loc, expr,
                                                 operands.take_front(numDims),
                                                 operands.drop_front(numDims));
                       }));
static AffineIfOp hoistAffineIfOp(AffineIfOp ifOp, Operation *hoistOverOp) {
   elseBlock->getOperations().splice(
       elseBlock->begin(), hoistOverOpClone->getBlock()->getOperations(),
       Block::iterator(hoistOverOpClone));
 
   return hoistedIfOp;
 }
 
 LogicalResult
-mlir::affineParallelize(AffineForOp forOp,
+mlir::affine::affineParallelize(AffineForOp forOp,
                                 ArrayRef<LoopReduction> parallelReductions) {
   // Fail early if there are iter arguments that are not reductions.
   unsigned numReductions = parallelReductions.size();
   if (numReductions != forOp.getNumIterOperands())
     return failure();
 
   Location loc = forOp.getLoc();
   OpBuilder outsideBuilder(forOp);
   AffineMap lowerBoundMap = forOp.getLowerBoundMap();
mlir::affine::affineParallelize(AffineForOp forOp,
   yieldOp->setOperands(reducedValues);
   newPloop.getBody()->eraseArguments(numIVs, numReductions);
 
   forOp.erase();
   return success();
 }
 
 // Returns success if any hoisting happened.
-LogicalResult mlir::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
+LogicalResult mlir::affine::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
   // Bail out early if the ifOp returns a result.  TODO: Consider how to
   // properly support this case.
   if (ifOp.getNumResults() != 0)
     return failure();
 
   // Apply canonicalization patterns and folding - this is necessary for the
   // hoisting check to be correct (operands should be composed), and to be more
   // effective (no unused operands). Since the pattern rewriter's folding is
LogicalResult mlir::affine::hoistAffineIfOp(AffineIfOp ifOp, bool *folded) {
   (void)applyPatternsAndFoldGreedily(
       hoistedIfOp->getParentWithTrait<OpTrait::IsIsolatedFromAbove>(),
       frozenPatterns);
 
   return success();
 }
 
 // Return the min expr after replacing the given dim.
-AffineExpr mlir::substWithMin(AffineExpr e, AffineExpr dim, AffineExpr min,
-                              AffineExpr max, bool positivePath) {
+AffineExpr mlir::affine::substWithMin(AffineExpr e, AffineExpr dim,
+                                      AffineExpr min, AffineExpr max,
+                                      bool positivePath) {
   if (e == dim)
     return positivePath ? min : max;
   if (auto bin = e.dyn_cast<AffineBinaryOpExpr>()) {
     AffineExpr lhs = bin.getLHS();
     AffineExpr rhs = bin.getRHS();
     if (bin.getKind() == mlir::AffineExprKind::Add)
       return substWithMin(lhs, dim, min, max, positivePath) +
              substWithMin(rhs, dim, min, max, positivePath);
 
     auto c1 = bin.getLHS().dyn_cast<AffineConstantExpr>();
     auto c2 = bin.getRHS().dyn_cast<AffineConstantExpr>();
     if (c1 && c1.getValue() < 0)
       return getAffineBinaryOpExpr(
           bin.getKind(), c1, substWithMin(rhs, dim, min, max, !positivePath));
     if (c2 && c2.getValue() < 0)
       return getAffineBinaryOpExpr(
           bin.getKind(), substWithMin(lhs, dim, min, max, !positivePath), c2);
     return getAffineBinaryOpExpr(
         bin.getKind(), substWithMin(lhs, dim, min, max, positivePath),
         substWithMin(rhs, dim, min, max, positivePath));
   }
   return e;
 }
 
-void mlir::normalizeAffineParallel(AffineParallelOp op) {
+void mlir::affine::normalizeAffineParallel(AffineParallelOp op) {
   // Loops with min/max in bounds are not normalized at the moment.
   if (op.hasMinMaxBounds())
     return;
 
   AffineMap lbMap = op.getLowerBoundsMap();
   SmallVector<int64_t, 8> steps = op.getSteps();
   // No need to do any work if the parallel op is already normalized.
   bool isAlreadyNormalized =
void mlir::affine::normalizeAffineParallel(AffineParallelOp op) {
   op.setSteps(newSteps);
   auto newLowerMap = AffineMap::get(
       /*dimCount=*/0, /*symbolCount=*/0, lbExprs, op.getContext());
   op.setLowerBounds({}, newLowerMap);
   auto newUpperMap = AffineMap::get(ranges.getNumDims(), ranges.getNumSymbols(),
                                     ubExprs, op.getContext());
   op.setUpperBounds(ranges.getOperands(), newUpperMap);
 }
-LogicalResult mlir::normalizeAffineFor(AffineForOp op, bool promoteSingleIter) {
+LogicalResult mlir::affine::normalizeAffineFor(AffineForOp op,
+                                               bool promoteSingleIter) {
   if (promoteSingleIter && succeeded(promoteIfSingleIteration(op)))
     return success();
 
   // Check if the forop is already normalized.
   if (op.hasConstantLowerBound() && (op.getConstantLowerBound() == 0) &&
       (op.getStep() == 1))
     return success();
 
if (srcAccess.memref == destAccess.memref &&
     return false;
   }
   // TODO: Check here if the memrefs alias: there is no side effect if
   // `srcAccess.memref` and `destAccess.memref` don't alias.
   return true;
 }
 
 template <typename EffectType, typename T>
-bool mlir::hasNoInterveningEffect(Operation *start, T memOp) {
+bool mlir::affine::hasNoInterveningEffect(Operation *start, T memOp) {
   auto isLocallyAllocated = [](Value memref) {
     auto *defOp = memref.getDefiningOp();
     return defOp && hasSingleEffect<MemoryEffects::Allocate>(defOp, memref);
   };
 
   // A boolean representing whether an intervening operation could have impacted
   // memOp.
   bool hasSideEffect = false;
for (auto *user : loadOp.getMemRef().getUsers()) {
     // guarantees this for accesses in the same block. The load could be in a
     // nested block that is unreachable.
     if (storeOp->getBlock() != loadOp->getBlock() &&
         !mustReachAtInnermost(srcAccess, destAccess))
       continue;
 
     // 4. Ensure there is no intermediate operation which could replace the
     // value in memory.
-    if (!mlir::hasNoInterveningEffect<MemoryEffects::Write>(storeOp, loadOp))
+    if (!affine::hasNoInterveningEffect<MemoryEffects::Write>(storeOp, loadOp))
       continue;
 
     // We now have a candidate for forwarding.
     assert(lastWriteStoreOp == nullptr &&
            "multiple simultaneous replacement stores");
     lastWriteStoreOp = storeOp;
   }
 
static LogicalResult forwardStoreToLoad(
   loadOp.getValue().replaceAllUsesWith(storeVal);
   // Record the memref for a later sweep to optimize away.
   memrefsToErase.insert(loadOp.getMemRef());
   // Record this to erase later.
   loadOpsToErase.push_back(loadOp);
   return success();
 }
 
-template bool mlir::hasNoInterveningEffect<mlir::MemoryEffects::Read,
-                                           mlir::AffineReadOpInterface>(
-    mlir::Operation *, mlir::AffineReadOpInterface);
+template bool
+mlir::affine::hasNoInterveningEffect<mlir::MemoryEffects::Read,
+                                     affine::AffineReadOpInterface>(
+    mlir::Operation *, affine::AffineReadOpInterface);
 
 // This attempts to find stores which have no impact on the final result.
 // A writing op writeA will be eliminated if there exists an op writeB if
 // 1) writeA and writeB have mathematically equivalent affine access functions.
 // 2) writeB postdominates writeA.
 // 3) There is no potential read between writeA and writeB.
 static void findUnusedStore(AffineWriteOpInterface writeA,
                             SmallVectorImpl<Operation *> &opsToErase,
if (srcAccess != destAccess)
       continue;
 
     // writeB must postdominate writeA.
     if (!postDominanceInfo.postDominates(writeB, writeA))
       continue;
 
     // There cannot be an operation which reads from memory between
     // the two writes.
-    if (!mlir::hasNoInterveningEffect<MemoryEffects::Read>(writeA, writeB))
+    if (!affine::hasNoInterveningEffect<MemoryEffects::Read>(writeA, writeB))
       continue;
 
     opsToErase.push_back(writeA);
     break;
   }
 }
 
 // The load to load forwarding / redundant load elimination is similar to the
if (srcAccess != destAccess) {
       continue;
     }
 
     // 2. The store has to dominate the load op to be candidate.
     if (!domInfo.dominates(loadB, loadA))
       continue;
 
     // 3. There is no write between loadA and loadB.
-    if (!mlir::hasNoInterveningEffect<MemoryEffects::Write>(
+    if (!affine::hasNoInterveningEffect<MemoryEffects::Write>(
             loadB.getOperation(), loadA))
       continue;
 
     // Check if two values have the same shape. This is needed for affine vector
     // loads.
     if (loadB.getValue().getType() != loadA.getValue().getType())
       continue;
 

 // multiple sources to forward from.
 //
 // TODO: more forwarding can be done when support for
 // loop/conditional live-out SSA values is available.
 // TODO: do general dead store elimination for memref's. This pass
 // currently only eliminates the stores only if no other loads/uses (other
 // than dealloc) remain.
 //
-void mlir::affineScalarReplace(func::FuncOp f, DominanceInfo &domInfo,
+void mlir::affine::affineScalarReplace(func::FuncOp f, DominanceInfo &domInfo,
                                        PostDominanceInfo &postDomInfo) {
   // Load op's whose results were replaced by those forwarded from stores.
   SmallVector<Operation *, 8> opsToErase;
 
   // A list of memref's that are potentially dead / could be eliminated.
   SmallPtrSet<Value, 4> memrefsToErase;
 
   // Walk all load's and perform store to load forwarding.
   f.walk([&](AffineReadOpInterface loadOp) {
for (auto memref : memrefsToErase) {
     // Erase all stores, the dealloc, and the alloc on the memref.
     for (auto *user : llvm::make_early_inc_range(memref.getUsers()))
       user->erase();
     defOp->erase();
   }
 }
 
 // Perform the replacement in `op`.
-LogicalResult mlir::replaceAllMemRefUsesWith(Value oldMemRef, Value newMemRef,
-                                             Operation *op,
-                                             ArrayRef<Value> extraIndices,
-                                             AffineMap indexRemap,
-                                             ArrayRef<Value> extraOperands,
-                                             ArrayRef<Value> symbolOperands,
-                                             bool allowNonDereferencingOps) {
+LogicalResult mlir::affine::replaceAllMemRefUsesWith(
+    Value oldMemRef, Value newMemRef, Operation *op,
+    ArrayRef<Value> extraIndices, AffineMap indexRemap,
+    ArrayRef<Value> extraOperands, ArrayRef<Value> symbolOperands,
   unsigned newMemRefRank = newMemRef.getType().cast<MemRefType>().getRank();
   (void)newMemRefRank; // unused in opt mode
   unsigned oldMemRefRank = oldMemRef.getType().cast<MemRefType>().getRank();
   (void)oldMemRefRank; // unused in opt mode
   if (indexRemap) {
     assert(indexRemap.getNumSymbols() == symbolOperands.size() &&
            "symbolic operand count mismatch");
     assert(indexRemap.getNumInputs() ==
LogicalResult mlir::affine::replaceAllMemRefUsesWith(
   // Create the new operation.
   auto *repOp = builder.create(state);
   op->replaceAllUsesWith(repOp);
   op->erase();
 
   return success();
 }
 
-LogicalResult mlir::replaceAllMemRefUsesWith(
+LogicalResult mlir::affine::replaceAllMemRefUsesWith(
     Value oldMemRef, Value newMemRef, ArrayRef<Value> extraIndices,
     AffineMap indexRemap, ArrayRef<Value> extraOperands,
     ArrayRef<Value> symbolOperands, Operation *domOpFilter,
     Operation *postDomOpFilter, bool allowNonDereferencingOps,
     bool replaceInDeallocOp) {
   unsigned newMemRefRank = newMemRef.getType().cast<MemRefType>().getRank();
   (void)newMemRefRank; // unused in opt mode
   unsigned oldMemRefRank = oldMemRef.getType().cast<MemRefType>().getRank();

 /// This allows applying different transformations on send and compute (for eg.
 /// different shifts/delays).
 ///
 /// Returns nullptr either if none of opInst's operands were the result of an
 /// affine.apply and thus there was no affine computation slice to create, or if
 /// all the affine.apply op's supplying operands to this opInst did not have any
 /// uses besides this opInst; otherwise returns the list of affine.apply
 /// operations created in output argument `sliceOps`.
-void mlir::createAffineComputationSlice(
+void mlir::affine::createAffineComputationSlice(
     Operation *opInst, SmallVectorImpl<AffineApplyOp> *sliceOps) {
   // Collect all operands that are results of affine apply ops.
   SmallVector<Value, 4> subOperands;
   subOperands.reserve(opInst->getNumOperands());
   for (auto operand : opInst->getOperands())
     if (isa_and_nonnull<AffineApplyOp>(operand.getDefiningOp()))
       subOperands.push_back(operand);
 
if (newMemRefShape[newDimIdx] < 0) {
           b.create<AffineApplyOp>(allocOp->getLoc(), newMap, inAffineApply);
       newDynamicSizes.emplace_back(affineApp);
     }
     newDimIdx++;
   }
 }
 
 // TODO: Currently works for static memrefs with a single layout map.
-LogicalResult mlir::normalizeMemRef(memref::AllocOp *allocOp) {
+LogicalResult mlir::affine::normalizeMemRef(memref::AllocOp *allocOp) {
   MemRefType memrefType = allocOp->getType();
   OpBuilder b(*allocOp);
 
   // Fetch a new memref type after normalizing the old memref to have an
   // identity map layout.
   MemRefType newMemRefType =
       normalizeMemRefType(memrefType, allocOp->getSymbolOperands().size());
   if (newMemRefType == memrefType)
LogicalResult mlir::affine::normalizeMemRef(memref::AllocOp *allocOp) {
   assert(llvm::all_of(oldMemRef.getUsers(), [&](Operation *op) {
     return hasSingleEffect<MemoryEffects::Free>(op, oldMemRef);
   }));
   oldMemRef.replaceAllUsesWith(newAlloc);
   allocOp->erase();
   return success();
 }
 
-MemRefType mlir::normalizeMemRefType(MemRefType memrefType,
+MemRefType mlir::affine::normalizeMemRefType(MemRefType memrefType,
                                              unsigned numSymbolicOperands) {
   unsigned rank = memrefType.getRank();
   if (rank == 0)
     return memrefType;
 
   if (memrefType.getLayout().isIdentity()) {
     // Either no maps is associated with this memref or this memref has
     // a trivial (identity) map.
     return memrefType;
MemRefType mlir::affine::normalizeMemRefType(MemRefType memrefType,
   MemRefType newMemRefType =
       MemRefType::Builder(memrefType)
           .setShape(newShape)
           .setLayout(AffineMapAttr::get(
               AffineMap::getMultiDimIdentityMap(newRank, context)));
   return newMemRefType;
 }
 
-DivModValue mlir::getDivMod(OpBuilder &b, Location loc, Value lhs, Value rhs) {
+DivModValue mlir::affine::getDivMod(OpBuilder &b, Location loc, Value lhs,
+                                    Value rhs) {
   DivModValue result;
   AffineExpr d0, d1;
   bindDims(b.getContext(), d0, d1);
   result.quotient =
-      makeComposedAffineApply(b, loc, d0.floorDiv(d1), {lhs, rhs});
-  result.remainder = makeComposedAffineApply(b, loc, d0 % d1, {lhs, rhs});
+      affine::makeComposedAffineApply(b, loc, d0.floorDiv(d1), {lhs, rhs});
+  result.remainder =
+      affine::makeComposedAffineApply(b, loc, d0 % d1, {lhs, rhs});
   return result;
 }
 
 /// Create IR that computes the product of all elements in the set.
 static FailureOr<OpFoldResult> getIndexProduct(OpBuilder &b, Location loc,
                                                ArrayRef<Value> set) {
   if (set.empty())
     return failure();
   OpFoldResult result = set[0];
   AffineExpr s0, s1;
   bindSymbols(b.getContext(), s0, s1);
   for (unsigned i = 1, e = set.size(); i < e; i++)
     result = makeComposedFoldedAffineApply(b, loc, s0 * s1, {result, set[i]});
   return result;
 }
 
-FailureOr<SmallVector<Value>> mlir::delinearizeIndex(OpBuilder &b, Location loc,
-                                                     Value linearIndex,
-                                                     ArrayRef<Value> basis) {
+FailureOr<SmallVector<Value>>
+mlir::affine::delinearizeIndex(OpBuilder &b, Location loc, Value linearIndex,
   unsigned numDims = basis.size();
 
   SmallVector<Value> divisors;
   for (unsigned i = 1; i < numDims; i++) {
     ArrayRef<Value> slice = basis.drop_front(i);
     FailureOr<OpFoldResult> prod = getIndexProduct(b, loc, slice);
     if (failed(prod))
       return failure();

mlir/lib/Dialect/Affine/Utils/ViewLikeInterfaceUtils.cpp

 //===- ViewLikeInterfaceUtils.cpp -----------------------------------------===//
 //
 // 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/Dialect/Affine/ViewLikeInterfaceUtils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arith/Utils/Utils.h"
 #include "mlir/IR/PatternMatch.h"
 
 using namespace mlir;
+using namespace affine;
 
-LogicalResult mlir::mergeOffsetsSizesAndStrides(
+LogicalResult mlir::affine::mergeOffsetsSizesAndStrides(
     OpBuilder &builder, Location loc, ArrayRef<OpFoldResult> producerOffsets,
     ArrayRef<OpFoldResult> producerSizes,
     ArrayRef<OpFoldResult> producerStrides,
     const llvm::SmallBitVector &droppedProducerDims,
     ArrayRef<OpFoldResult> consumerOffsets,
     ArrayRef<OpFoldResult> consumerSizes,
     ArrayRef<OpFoldResult> consumerStrides,
     SmallVector<OpFoldResult> &combinedOffsets,
combinedStrides[i] = makeComposedFoldedAffineApply(
         builder, loc, s0 * s1,
         {consumerStrides[consumerPos], producerStrides[i]});
 
     consumerPos++;
   }
   return success();
 }
 
-LogicalResult mlir::mergeOffsetsSizesAndStrides(
+LogicalResult mlir::affine::mergeOffsetsSizesAndStrides(
     OpBuilder &builder, Location loc, OffsetSizeAndStrideOpInterface producer,
     OffsetSizeAndStrideOpInterface consumer,
     const llvm::SmallBitVector &droppedProducerDims,
     SmallVector<OpFoldResult> &combinedOffsets,
     SmallVector<OpFoldResult> &combinedSizes,
     SmallVector<OpFoldResult> &combinedStrides) {
   SmallVector<OpFoldResult> consumerOffsets = consumer.getMixedOffsets();
   SmallVector<OpFoldResult> consumerSizes = consumer.getMixedSizes();
   SmallVector<OpFoldResult> consumerStrides = consumer.getMixedStrides();
   SmallVector<OpFoldResult> producerOffsets = producer.getMixedOffsets();
   SmallVector<OpFoldResult> producerSizes = producer.getMixedSizes();
   SmallVector<OpFoldResult> producerStrides = producer.getMixedStrides();
   return mergeOffsetsSizesAndStrides(
       builder, loc, producerOffsets, producerSizes, producerStrides,
       droppedProducerDims, consumerOffsets, consumerSizes, consumerStrides,
       combinedOffsets, combinedSizes, combinedStrides);
 }
 
-void mlir::resolveIndicesIntoOpWithOffsetsAndStrides(
+void mlir::affine::resolveIndicesIntoOpWithOffsetsAndStrides(
     RewriterBase &rewriter, Location loc,
     ArrayRef<OpFoldResult> mixedSourceOffsets,
     ArrayRef<OpFoldResult> mixedSourceStrides,
     const llvm::SmallBitVector &rankReducedDims,
     ArrayRef<OpFoldResult> consumerIndices,
     SmallVectorImpl<Value> &resolvedIndices) {
   OpFoldResult zero = rewriter.getIndexAttr(0);
 
for (auto [offset, index, stride] :
     OpFoldResult ofr = makeComposedFoldedAffineApply(
         rewriter, loc, AffineMap::get(0, 3, off + idx * str),
         {offset, index, stride});
     resolvedIndices.push_back(
         getValueOrCreateConstantIndexOp(rewriter, loc, ofr));
   }
 }
 
-void mlir::resolveSizesIntoOpWithSizes(
+void mlir::affine::resolveSizesIntoOpWithSizes(
     ArrayRef<OpFoldResult> sourceSizes, ArrayRef<OpFoldResult> destSizes,
     const llvm::SmallBitVector &rankReducedSourceDims,
     SmallVectorImpl<OpFoldResult> &resolvedSizes) {
   int64_t dim = 0;
   int64_t srcRank = sourceSizes.size();
   for (int64_t srcDim = 0; srcDim < srcRank; ++srcDim) {
     if (rankReducedSourceDims[srcDim]) {
       resolvedSizes.push_back(sourceSizes[srcDim]);
       continue;
     }
     resolvedSizes.push_back(destSizes[dim++]);
   }
 }

mlir/lib/Dialect/GPU/TransformOps/GPUTransformOps.cpp

static Value buildLinearThreadId(RewriterBase &rewriter, Location loc,
   bindSymbols(rewriter.getContext(), BDX, BDY);
   IndexType indexType = rewriter.getIndexType();
   SmallVector<OpFoldResult> threadsAndWorkGroups{
       rewriter.create<ThreadIdOp>(loc, indexType, Dimension::x).getResult(),
       rewriter.create<ThreadIdOp>(loc, indexType, Dimension::y).getResult(),
       rewriter.create<ThreadIdOp>(loc, indexType, Dimension::z).getResult()};
   threadsAndWorkGroups.push_back(blockDimsOfr[0]);
   threadsAndWorkGroups.push_back(blockDimsOfr[1]);
-  OpFoldResult ofr = makeComposedFoldedAffineApply(
+  OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
       rewriter, loc, tx + ty * BDX + tz * BDX * BDY, threadsAndWorkGroups);
   return getValueOrCreateConstantIndexOp(rewriter, loc, ofr);
 }
 
 /// Builder for gpu::BlockIdOps used in mapping scf.forall to blocks.
 /// The `idBuilder` method returns 3-D values used for indexing rewrites as well
 /// as 3-D sizes for predicate generation.
 struct GpuBlockIdBuilder : public GpuIdBuilder {
mappingAttributes = {GPUWarpMappingAttr::get(ctx, Warps::DimX),
                          GPUWarpMappingAttr::get(ctx, Warps::DimY),
                          GPUWarpMappingAttr::get(ctx, Warps::DimZ)};
     idBuilder = [this](RewriterBase &rewriter, Location loc,
                        ArrayRef<int64_t> forallMappingSizes) {
       // Build the linear warp id and decompose it in the basis of
       // `forallMappingSizes`.
       Value linearId = buildLinearThreadId(rewriter, loc, this->blockDimsOfr);
       AffineExpr d0 = getAffineDimExpr(0, rewriter.getContext());
-      OpFoldResult warpIdOfr = makeComposedFoldedAffineApply(
+      OpFoldResult warpIdOfr = affine::makeComposedFoldedAffineApply(
           rewriter, loc, d0.floorDiv(kWarpSize), {linearId});
       Value warpId = getValueOrCreateConstantIndexOp(rewriter, loc, warpIdOfr);
       // Sizes in [x, y, z] -> [z, y x] order to properly compute strides in
       // "row-major" order.
       SmallVector<int64_t> reverseBasisSizes(
           llvm::reverse(this->availableMappingSizes));
       SmallVector<int64_t> strides = computeStrides(reverseBasisSizes);
       SmallVector<AffineExpr> delinearizingExprs = delinearize(d0, strides);
       SmallVector<Value> ids;
       // Reverse back to be in [x, y, z] order.
       for (AffineExpr e : llvm::reverse(delinearizingExprs))
-        ids.push_back(makeComposedAffineApply(rewriter, loc, e, warpId));
+        ids.push_back(
+            affine::makeComposedAffineApply(rewriter, loc, e, warpId));
 
       // clang-format off
       LDBG("----linearId: " << linearId);
           LDBG("----warpId: " << warpId);
       LLVM_DEBUG(llvm::interleaveComma(reverseBasisSizes,
                                        DBGS() << "--delinearization basis: ");
                  llvm::dbgs() << "\n";
                  llvm::interleaveComma(strides,
idBuilder = [this](RewriterBase &rewriter, Location loc,
       SmallVector<int64_t> reverseBasisSizes(llvm::reverse(forallMappingSizes));
       SmallVector<int64_t> strides = computeStrides(reverseBasisSizes);
       AffineExpr d0;
       bindDims(rewriter.getContext(), d0);
       SmallVector<AffineExpr> delinearizingExprs = delinearize(d0, strides);
       SmallVector<Value> ids;
       // Reverse back to be in [x, y, z] order.
       for (AffineExpr e : llvm::reverse(delinearizingExprs))
-        ids.push_back(makeComposedAffineApply(rewriter, loc, e, linearId));
+        ids.push_back(
+            affine::makeComposedAffineApply(rewriter, loc, e, linearId));
 
       // clang-format off
       LLVM_DEBUG(llvm::interleaveComma(reverseBasisSizes,
                                        DBGS() << "--delinearization basis: ");
                  llvm::dbgs() << "\n";
                  llvm::interleaveComma(strides,
                                        DBGS() << "--delinearization strides: ");
                  llvm::dbgs() << "\n";

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

mlir::scf::buildLoopNest(
       });
 
   // Map the innermost loops to threads in reverse order.
   for (const auto &en :
        llvm::enumerate(llvm::reverse(llvm::ArrayRef(ivs).take_back(
            GPUDialect::getNumWorkgroupDimensions())))) {
     Value v = en.value();
     auto loop = cast<scf::ForOp>(v.getParentRegion()->getParentOp());
-    mapLoopToProcessorIds(loop, {threadIds[en.index()]},
+    affine::mapLoopToProcessorIds(loop, {threadIds[en.index()]},
                                   {blockDims[en.index()]});
   }
 }
 
 /// Emits the loop nests performing the copy to the designated location in the
 /// beginning of the region, and from the designated location immediately before
 /// the terminator of the first block of the region. The region is expected to
 /// have one block. This boils down to the following structure
 ///

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

LinalgOp::reifyResultShapes(OpBuilder &b,
   // Check that the result dim map does not contain the positions corresponding
   // to the outputs.
   llvm::SmallBitVector outputDims(resultShapesFromInputShapesMap.getNumDims());
   outputDims.set(resultShapesSubMapPos.first, resultShapesSubMapPos.second);
   HasAffineDimExprVisitor checkDimExpr(std::move(outputDims));
   Location loc = getOperation()->getLoc();
   IRRewriter rewriter(b);
   SmallVector<OpFoldResult> allResultDimValues =
-      makeComposedFoldedMultiResultAffineApply(
+      affine::makeComposedFoldedMultiResultAffineApply(
           rewriter, loc, resultShapesFromInputShapesMap,
           createFlatListOfOperandDims(b, loc));
   int64_t pos = 0;
   ArrayRef<AffineExpr> shapeExprs = resultShapesFromInputShapesMap.getResults();
   for (OpOperand *opOperand : getDpsInitOperands()) {
     SmallVector<OpFoldResult> shapes;
     for (int64_t dim : llvm::seq<int64_t>(0, getRank(opOperand))) {
       auto shapedType = opOperand->get().getType().cast<ShapedType>();

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

LogicalResult matchAndRewrite(tensor::InsertSliceOp insertOp,
     AffineExpr sym0, sym1;
     bindSymbols(context, sym0, sym1);
     auto addMap = AffineMap::get(0, 2, {sym0 + sym1}, context);
 
     // Calculate the new offsets for the insert. It should be the old offsets
     // plus low padding sizes.
     SmallVector<OpFoldResult, 4> newOffsets;
     for (const auto &p : llvm::zip(lowPads, oldOffsets)) {
-      newOffsets.push_back(makeComposedFoldedAffineApply(
+      newOffsets.push_back(affine::makeComposedFoldedAffineApply(
           rewriter, loc, addMap, {std::get<0>(p), std::get<1>(p)}));
     }
 
     SmallVector<OpFoldResult, 4> newSizes;
     for (int i = 0, e = srcPadOp.getSourceType().getRank(); i < e; ++i) {
       newSizes.push_back(
           rewriter.create<tensor::DimOp>(loc, srcPadOp.getSource(), i)
               .getResult());

mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp

FailureOr<MultiSizeSpecification> spec = computeMultiTileSizes(
       builder, target, getDimension(), targetSize, divisor);
   if (failed(spec)) {
     return emitSilenceableError() << "could not generate tile size computation";
   }
 
   AffineExpr s0 = builder.getAffineSymbolExpr(0);
   AffineExpr s1 = builder.getAffineSymbolExpr(1);
   Operation *splitPoint =
-      makeComposedAffineApply(builder, target.getLoc(), s0 * s1,
+      affine::makeComposedAffineApply(builder, target.getLoc(), s0 * s1,
                                       {spec->lowTileSize, spec->lowTripCount});
   Operation *lowTileSize = spec->lowTileSize.getDefiningOp();
   Operation *highTileSize = spec->highTileSize.getDefiningOp();
   assert(lowTileSize && highTileSize && splitPoint &&
          "tile sizes are not produced by operations");
   results.reserve(results.size() + 3);
   results.push_back(lowTileSize);
   results.push_back(highTileSize);
   results.push_back(splitPoint);
packMatmulGreedily(RewriterBase &rewriter, LinalgOp linalgOp,
   for (int64_t i = 0, e = numPackedDims; i < e; ++i) {
     if (paddedSizesNextMultipleOf[i] == 0) {
       adjustedPackedSizes.push_back(packedSizes[i]);
       continue;
     }
     AffineExpr d0, s0;
     bindDims(rewriter.getContext(), d0);
     bindSymbols(rewriter.getContext(), s0);
-    adjustedPackedSizes.push_back(makeComposedFoldedAffineApply(
+    adjustedPackedSizes.push_back(affine::makeComposedFoldedAffineApply(
         rewriter, genericOp->getLoc(), d0.ceilDiv(s0) * s0,
         {loopRanges[adjustedPackedSizes.size()].size,
          rewriter.getIndexAttr(paddedSizesNextMultipleOf[i])}));
   }
   LLVM_DEBUG(llvm::interleaveComma(adjustedPackedSizes,
                                    DBGS() << "adjustedPackedSizes: ");
              DBGSNL(););
 
tilingOptions.setTileSizeComputationFunction([&](OpBuilder &b, Operation *) {
     Location loc = target.getLoc();
     SmallVector<OpFoldResult> allShapeSizes =
         target.createFlatListOfOperandDims(b, loc);
     AffineMap map = target.getShapesToLoopsMap();
     if (!map)
       return tileSizes;
     IRRewriter rewriter(b);
     SmallVector<OpFoldResult> shapeSizes =
-        makeComposedFoldedMultiResultAffineApply(rewriter, loc, map,
+        affine::makeComposedFoldedMultiResultAffineApply(rewriter, loc, map,
                                                          allShapeSizes);
     // If the shape size is dynamic, tile by 1.
     // Otherwise, do not tile (i.e. tile size 0).
     for (OpFoldResult shapeSize : shapeSizes) {
       tileSizes.push_back(getConstantIntValue(shapeSize)
                               ? b.create<arith::ConstantIndexOp>(loc, 0)
                               : b.create<arith::ConstantIndexOp>(loc, 1));
     }
     return tileSizes;
class LinalgTransformDialectExtension
     : public transform::TransformDialectExtension<
           LinalgTransformDialectExtension> {
 public:
   using Base::Base;
 
   void init() {
     declareDependentDialect<pdl::PDLDialect>();
     declareDependentDialect<LinalgDialect>();
-    declareGeneratedDialect<AffineDialect>();
+    declareGeneratedDialect<affine::AffineDialect>();
     declareGeneratedDialect<arith::ArithDialect>();
     declareGeneratedDialect<scf::SCFDialect>();
     declareGeneratedDialect<vector::VectorDialect>();
     declareGeneratedDialect<gpu::GPUDialect>();
 
     registerTransformOps<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp.inc"

mlir/lib/Dialect/Linalg/Transforms/BubbleUpExtractSlice.cpp

LogicalResult matchAndRewrite(tensor::ExtractSliceOp sliceOp,
     SmallVector<OpFoldResult> allShapeSizes =
         linalgOp.createFlatListOfOperandDims(rewriter, linalgLoc);
     AffineMap shapeSizesToLoopsMap = linalgOp.getShapesToLoopsMap();
     if (!shapeSizesToLoopsMap) {
       return rewriter.notifyMatchFailure(
           linalgOp, "failed to get loops map from shape sizes");
     }
     SmallVector<OpFoldResult> sizeBounds =
-        makeComposedFoldedMultiResultAffineApply(
+        affine::makeComposedFoldedMultiResultAffineApply(
             rewriter, linalgLoc, shapeSizesToLoopsMap, allShapeSizes);
 
     // The offsets and sizes from the slice operation only give you the tile
     // size of the output. Use that compute the tile sizes and offsets of the
     // loops. For loops not used to access the output, set the tile sizes to
     // loop bounds and set the offset to 0.
     SmallVector<OpFoldResult> tileOffsets(sizeBounds.size(),
                                           rewriter.getIndexAttr(0));

mlir/lib/Dialect/Linalg/Transforms/ConvertConv2DToImg2Col.cpp

 // Delinearizes the given composite `index` by the basis specified in `factors`.
 static SmallVector<Value> unrollIndex(OpBuilder &b, Location loc, Value index,
                                       ArrayRef<int64_t> factors) {
   assert(!factors.empty() && "empty factor list");
   SmallVector<Value> basis;
   for (int64_t f : factors)
     basis.push_back(b.create<arith::ConstantOp>(loc, b.getIndexAttr(f)));
   FailureOr<SmallVector<Value>> multiIndex =
-      delinearizeIndex(b, loc, index, basis);
+      affine::delinearizeIndex(b, loc, index, basis);
   assert(!failed(multiIndex) && "Failed to linearize img2col index");
   return *multiIndex;
 }
 
 // Given indices corresponding to iterators in the output (oIndex) and filter
 // (fIndex) for a convolution, compute the convolved index for the
 // input as `oIndex * stride + fIndex`.
 static Value getConvolvedIndex(OpBuilder &b, Location loc, Value oIndex,
                                Value fIndex, int64_t stride) {
   AffineExpr oExpr, fExpr;
   bindSymbols(b.getContext(), oExpr, fExpr);
   AffineMap convMap = AffineMap::get(0, 2, stride * oExpr + fExpr);
-  return makeComposedAffineApply(b, loc, convMap, ValueRange{oIndex, fIndex});
+  return affine::makeComposedAffineApply(b, loc, convMap,
+                                         ValueRange{oIndex, fIndex});
 }
 
 FailureOr<std::pair<Operation *, Operation *>>
 rewriteInIm2Col(RewriterBase &rewriter, linalg::Conv2DNhwcHwcfOp convOp) {
   auto inputType = convOp.getInputs()[0].getType().cast<ShapedType>();
   auto filterType = convOp.getInputs()[1].getType().cast<ShapedType>();
   auto outputType = convOp.getOutputs()[0].getType().cast<ShapedType>();
 

mlir/lib/Dialect/Linalg/Transforms/DecomposeLinalgOps.cpp

static SmallVector<OpFoldResult> getGenericOpLoopRange(OpBuilder &b,
                                                        GenericOp op) {
   OpBuilder::InsertionGuard g(b);
   b.setInsertionPoint(op);
   Location loc = op.getLoc();
   auto allShapesSizes =
       cast<LinalgOp>(op.getOperation()).createFlatListOfOperandDims(b, loc);
   AffineMap map = op.getShapesToLoopsMap();
   IRRewriter rewriter(b);
-  return makeComposedFoldedMultiResultAffineApply(rewriter, loc, map,
+  return affine::makeComposedFoldedMultiResultAffineApply(rewriter, loc, map,
                                                           allShapesSizes);
 }
 
 /// Helper method to permute the list of `values` based on the `map`.
 SmallVector<OpFoldResult> permuteValues(ArrayRef<OpFoldResult> values,
                                         AffineMap map) {
   assert(map.isPermutation());
   SmallVector<OpFoldResult> permutedValues(values.size());
   for (const auto &position :

mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp

if (producer.hasIndexSemantics()) {
     SmallVector<Value> fusedIndices;
     fusedIndices.reserve(numFusedOpLoops);
     llvm::transform(llvm::seq<uint64_t>(0, numFusedOpLoops),
                     std::back_inserter(fusedIndices), [&](uint64_t dim) {
                       return rewriter.create<IndexOp>(producer.getLoc(), dim);
                     });
     for (IndexOp indexOp :
          llvm::make_early_inc_range(producerBlock.getOps<IndexOp>())) {
-      Value newIndex = rewriter.create<mlir::AffineApplyOp>(
+      Value newIndex = rewriter.create<affine::AffineApplyOp>(
           producer.getLoc(),
           consumerToProducerLoopsMap.getSubMap(indexOp.getDim()), fusedIndices);
       mapper.map(indexOp.getResult(), newIndex);
     }
   }
   // TODO: allow fusing the producer of an output operand.
   assert(consumer.isDpsInput(fusedOperand) &&
          "expected producer of input operand");
for (IndexOp indexOp :
     llvm::transform(
         expandedDims.drop_front(), std::back_inserter(expandedIndices),
         [&](int64_t dim) { return rewriter.create<IndexOp>(loc, dim); });
     Value newIndex = rewriter.create<IndexOp>(loc, expandedDims.front());
     for (auto it : llvm::zip(expandedDimsShape, expandedIndices)) {
       assert(!ShapedType::isDynamic(std::get<0>(it)));
       AffineExpr idx, acc;
       bindDims(rewriter.getContext(), idx, acc);
-      newIndex = rewriter.create<AffineApplyOp>(
+      newIndex = rewriter.create<affine::AffineApplyOp>(
           indexOp.getLoc(), idx + acc * std::get<0>(it),
           ValueRange{std::get<1>(it), newIndex});
     }
     rewriter.replaceOp(indexOp, newIndex);
   }
 }
 
 /// Implements the fusion of a tensor.collapse_shape or a tensor.expand_shape op
ControlFusionFn defaultControlFn = [](OpOperand *fusedOperand) {
       return producer && producer->hasOneUse();
     };
 
     // Add elementwise op fusion patterns.
     populateElementwiseOpsFusionPatterns(patterns, defaultControlFn);
     populateFoldReshapeOpsByExpansionPatterns(patterns, defaultControlFn);
 
     // General canonicalization patterns.
-    AffineApplyOp::getCanonicalizationPatterns(patterns, context);
+    affine::AffineApplyOp::getCanonicalizationPatterns(patterns, context);
     GenericOp::getCanonicalizationPatterns(patterns, context);
     tensor::ExpandShapeOp::getCanonicalizationPatterns(patterns, context);
     tensor::CollapseShapeOp::getCanonicalizationPatterns(patterns, context);
     context->getLoadedDialect<LinalgDialect>()->getCanonicalizationPatterns(
         patterns);
 
     // Add constant folding patterns.
     populateConstantFoldLinalgOperations(patterns, defaultControlFn);

mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp

HoistPaddingAnalysis::getHoistedPackedTensorSizes(RewriterBase &rewriter,
 
   // Upper bound the packing loop lengths to size the packed tensor. Taking
   // upper bounds can make the sizes of the packed tensor independent of the
   // enclosing loops. This independence is a prerequisite for reusing the same
   // buffer for all enclosing loop iterations and hoisting its allocation out
   // of the enclosing loops.
   for (auto forOp : packingLoops) {
     // Compute an upper bound `ubVal` for the upper bound of `forOp`.
-    FailureOr<OpFoldResult> loopUb = reifyValueBound(
+    FailureOr<OpFoldResult> loopUb = affine::reifyValueBound(
         rewriter, loc, presburger::BoundType::UB, forOp.getUpperBound(),
         /*dim=*/std::nullopt, /*stopCondition=*/
         [&](Value v, std::optional<int64_t> d) {
           if (v == forOp.getUpperBound())
             return false;
           // Compute a bound that is independent of any affine op results.
           Operation *op = v.getDefiningOp();
           if (!op)
             return true;
-          return !isa<AffineMinOp, AffineMaxOp, AffineApplyOp>(op);
+          return !isa<affine::AffineMinOp, affine::AffineMaxOp,
+                      affine::AffineApplyOp>(op);
         },
         /*closedUB=*/true);
     assert(succeeded(loopUb) && "could not get upper bound");
     Value ubVal = getValueOrCreateConstantIndexOp(rewriter, loc, *loopUb);
 
     // Compute the maximal packing loop length as (ub - lb).ceilDiv(step) and
     // store the result to `dynamicTensorSizes`.
     // TODO: instead of using the lower bound of `forOp` directly, implement a
     // lower bound computation similar to the upper bound computation.
     AffineExpr lb, ub, step;
     bindDims(rewriter.getContext(), lb, ub);
     bindSymbols(rewriter.getContext(), step);
-    Value res = rewriter.createOrFold<AffineApplyOp>(
+    Value res = rewriter.createOrFold<affine::AffineApplyOp>(
         loc, (ub - lb).ceilDiv(step),
         ValueRange{forOp.getLowerBound(), ubVal,
                    cast<scf::ForOp>(forOp).getStep()});
     dynamicTensorSizes.push_back(res);
   }
 
   return dynamicTensorSizes;
 }
static Value buildLoopIterationCount(RewriterBase &rewriter, scf::ForOp outer,
   bindDims(ctx, iv, lb);
   bindSymbols(ctx, step);
   if (!isDefinedOutsideOrConstant(outer, forOp.getLowerBound()) ||
       !isDefinedOutsideOrConstant(outer, forOp.getStep()))
     return Value();
   Value ivVal = forOp.getInductionVar(), lbVal = forOp.getLowerBound(),
         stepVal = forOp.getStep();
   auto loc = forOp->getLoc();
-  return rewriter.createOrFold<AffineApplyOp>(
+  return rewriter.createOrFold<affine::AffineApplyOp>(
       loc, (iv - lb).ceilDiv(step), ValueRange{ivVal, lbVal, stepVal});
 }
 
 // Build a packing loop nest by iteratively traversing the backward slice and
 // clone the operations, iteratively stepping into the loops that we encounter.
 // The implementation proceeds in a stack-like fashion:
 //   1. Iteratively clone and step into the loops, pushing the
 //   `hoistedPackedTensor`

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

func.walk([&](vector::TransferReadOp transferRead) {
       if (!transferRead.getShapedType().isa<MemRefType>())
         return WalkResult::advance();
 
       LLVM_DEBUG(DBGS() << "Candidate for hoisting: "
                         << *transferRead.getOperation() << "\n");
       auto loop = dyn_cast<LoopLikeOpInterface>(transferRead->getParentOp());
       LLVM_DEBUG(DBGS() << "Parent op: " << *transferRead->getParentOp()
                         << "\n");
-      if (!isa_and_nonnull<scf::ForOp, AffineForOp>(loop))
+      if (!isa_and_nonnull<scf::ForOp, affine::AffineForOp>(loop))
         return WalkResult::advance();
 
       LLVM_DEBUG(DBGS() << "Candidate read: " << *transferRead.getOperation()
                         << "\n");
 
       SetVector<Operation *> forwardSlice;
       getForwardSlice(transferRead.getOperation(), &forwardSlice);
 
func.walk([&](vector::TransferReadOp transferRead) {
             transferWrite.getVectorMutable().assign(
                 newForOp.getResults().back());
             changed = true;
             loop.erase();
             // Need to interrupt and restart because erasing the loop messes up
             // the walk.
             return WalkResult::interrupt();
           })
-          .Case<AffineForOp>([&](AffineForOp affineForOp) {
+          .Case<affine::AffineForOp>([&](affine::AffineForOp affineForOp) {
             auto newForOp = replaceForOpWithNewYields(
                 b, affineForOp, transferRead.getVector(),
                 SmallVector<Value>{transferWrite.getVector()},
                 transferWrite.getVector());
             // Replace all uses of the `transferRead` with the corresponding
             // basic block argument.
             transferRead.getVector().replaceUsesWithIf(
                 newForOp.getLoopBody().getArguments().back(),

mlir/lib/Dialect/Linalg/Transforms/Interchange.cpp

for (IndexOp indexOp :
          llvm::make_early_inc_range(genericOp.getBody()->getOps<IndexOp>())) {
       rewriter.setInsertionPoint(indexOp);
       SmallVector<Value> allIndices;
       allIndices.reserve(genericOp.getNumLoops());
       llvm::transform(llvm::seq<uint64_t>(0, genericOp.getNumLoops()),
                       std::back_inserter(allIndices), [&](uint64_t dim) {
                         return rewriter.create<IndexOp>(indexOp->getLoc(), dim);
                       });
-      rewriter.replaceOpWithNewOp<AffineApplyOp>(
+      rewriter.replaceOpWithNewOp<affine::AffineApplyOp>(
           indexOp, permutationMap.getSubMap(indexOp.getDim()), allIndices);
     }
   }
 
   return genericOp;
 }

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

static SmallVector<Value> makeCanonicalAffineApplies(OpBuilder &b, Location loc,
 
   assert(map.getNumInputs() == vals.size());
   SmallVector<Value> res;
   res.reserve(map.getNumResults());
   auto dims = map.getNumDims();
   for (auto e : map.getResults()) {
     auto exprMap = AffineMap::get(dims, map.getNumSymbols(), e);
     SmallVector<Value> operands(vals.begin(), vals.end());
-    canonicalizeMapAndOperands(&exprMap, &operands);
-    res.push_back(b.create<AffineApplyOp>(loc, exprMap, operands));
+    affine::canonicalizeMapAndOperands(&exprMap, &operands);
+    res.push_back(b.create<affine::AffineApplyOp>(loc, exprMap, operands));
   }
   return res;
 }
 
 template <typename LoadOpTy, typename StoreOpTy, typename OpType>
 static void inlineRegionAndEmitStore(OpBuilder &b, Location loc, OpType op,
                                      ArrayRef<Value> indexedValues,
                                      ArrayRef<SmallVector<Value>> indexing,
for (Operation *loopOp : loopOps) {
     llvm::TypeSwitch<Operation *>(loopOp)
         .Case([&](scf::ParallelOp parallelOp) {
           allIvs.append(parallelOp.getInductionVars().begin(),
                         parallelOp.getInductionVars().end());
         })
         .Case([&](scf::ForOp forOp) {
           allIvs.push_back(forOp.getInductionVar());
         })
-        .Case([&](AffineForOp affineForOp) {
+        .Case([&](affine::AffineForOp affineForOp) {
           allIvs.push_back(affineForOp.getInductionVar());
         })
         .Default([&](Operation *op) { assert(false && "unexpected op"); });
   }
   assert(linalgOp.getNumLoops() == allIvs.size() &&
          "expected the number of loops and induction variables to match");
   // Replace the index operations in the body of the innermost loop op.
   if (!loopOps.empty()) {
     LoopLikeOpInterface loopOp = loopOps.back();
     for (IndexOp indexOp :
          llvm::make_early_inc_range(loopOp.getLoopBody().getOps<IndexOp>()))
       rewriter.replaceOp(indexOp, allIvs[indexOp.getDim()]);
   }
 }
 
 template <typename LoopTy>
 static FailureOr<LinalgLoops> linalgOpToLoopsImpl(RewriterBase &rewriter,
                                                   LinalgOp linalgOp) {
-  using LoadOpTy = std::conditional_t<std::is_same<LoopTy, AffineForOp>::value,
-                                      AffineLoadOp, memref::LoadOp>;
-  using StoreOpTy = std::conditional_t<std::is_same<LoopTy, AffineForOp>::value,
-                                       AffineStoreOp, memref::StoreOp>;
+  using LoadOpTy =
+      std::conditional_t<std::is_same<LoopTy, affine::AffineForOp>::value,
+                         affine::AffineLoadOp, memref::LoadOp>;
+  using StoreOpTy =
+      std::conditional_t<std::is_same<LoopTy, affine::AffineForOp>::value,
+                         affine::AffineStoreOp, memref::StoreOp>;
 
   // The flattened loopToOperandRangesMaps is expected to be an invertible
   // permutation map (which is asserted in the inverse calculation).
   assert(linalgOp.hasBufferSemantics() &&
          "expected linalg op with buffer semantics");
 
   auto loopRanges = linalgOp.createLoopRanges(rewriter, linalgOp.getLoc());
   auto iteratorTypes = linalgOp.getIteratorTypesArray();

 ///   1. Zero operand + returns a single AffineConstantExpr
 ///   2. One operand + returns a single AffineDimExpr
 ///   3. One operand + returns a single AffineSymbolExpr
 //
 /// In the first case, the AffineApplyOp is replaced by a new constant. In the
 /// other cases, it is replaced by its unique operand.
 struct FoldAffineOp : public RewritePattern {
   FoldAffineOp(MLIRContext *context)
-      : RewritePattern(AffineApplyOp::getOperationName(), 0, context) {}
+      : RewritePattern(affine::AffineApplyOp::getOperationName(), 0, context) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override {
-    AffineApplyOp affineApplyOp = cast<AffineApplyOp>(op);
+    auto affineApplyOp = cast<affine::AffineApplyOp>(op);
     auto map = affineApplyOp.getAffineMap();
     if (map.getNumResults() != 1 || map.getNumInputs() > 1)
       return failure();
 
     AffineExpr expr = map.getResult(0);
     if (map.getNumInputs() == 0) {
       if (auto val = expr.dyn_cast<AffineConstantExpr>()) {
         rewriter.replaceOpWithNewOp<arith::ConstantIndexOp>(op, val.getValue());

 
 template <typename LoopType>
 static void lowerLinalgToLoopsImpl(func::FuncOp funcOp) {
   MLIRContext *context = funcOp.getContext();
   RewritePatternSet patterns(context);
   patterns.add<LinalgRewritePattern<LoopType>>(context);
   memref::DimOp::getCanonicalizationPatterns(patterns, context);
   tensor::DimOp::getCanonicalizationPatterns(patterns, context);
-  AffineApplyOp::getCanonicalizationPatterns(patterns, context);
+  affine::AffineApplyOp::getCanonicalizationPatterns(patterns, context);
   patterns.add<FoldAffineOp>(context);
   // Just apply the patterns greedily.
   (void)applyPatternsAndFoldGreedily(funcOp, std::move(patterns));
 }
 
 struct LowerToAffineLoops
     : public impl::LinalgLowerToAffineLoopsBase<LowerToAffineLoops> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnOperation() override {
-    lowerLinalgToLoopsImpl<AffineForOp>(getOperation());
+    lowerLinalgToLoopsImpl<affine::AffineForOp>(getOperation());
   }
 };
 
 struct LowerToLoops : public impl::LinalgLowerToLoopsBase<LowerToLoops> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, scf::SCFDialect>();
   }
   void runOnOperation() override {

 std::unique_ptr<OperationPass<func::FuncOp>>
 mlir::createConvertLinalgToAffineLoopsPass() {
   return std::make_unique<LowerToAffineLoops>();
 }
 
 /// Emits a loop nest of `affine.for` with the proper body for `linalgOp`.
 FailureOr<LinalgLoops>
 mlir::linalg::linalgOpToAffineLoops(RewriterBase &rewriter, LinalgOp linalgOp) {
-  return linalgOpToLoopsImpl<AffineForOp>(rewriter, linalgOp);
+  return linalgOpToLoopsImpl<affine::AffineForOp>(rewriter, linalgOp);
 }
 
 /// Emits a loop nest of `scf.for` with the proper body for `linalgOp`.
 FailureOr<LinalgLoops> mlir::linalg::linalgOpToLoops(RewriterBase &rewriter,
                                                      LinalgOp linalgOp) {
   return linalgOpToLoopsImpl<scf::ForOp>(rewriter, linalgOp);
 }
 
 /// Emits a loop nest of `scf.parallel` with the proper body for `linalgOp`.
 FailureOr<LinalgLoops>
 mlir::linalg::linalgOpToParallelLoops(RewriterBase &rewriter,
                                       LinalgOp linalgOp) {
   return linalgOpToLoopsImpl<scf::ParallelOp>(rewriter, linalgOp);
 }

mlir/lib/Dialect/Linalg/Transforms/Split.cpp

linalg::splitOp(RewriterBase &rewriter, TilingInterface op, unsigned dimension,
   SmallVector<OpFoldResult> offsets = llvm::to_vector(llvm::map_range(
       iterationSpace, [](const Range &range) { return range.offset; }));
   SmallVector<OpFoldResult> sizes = llvm::to_vector(llvm::map_range(
       iterationSpace, [](const Range &range) { return range.size; }));
 
   // Adjust the split point so that it doesn't overflow the size.
   AffineExpr d0, d1, d2;
   bindDims(rewriter.getContext(), d0, d1, d2);
-  OpFoldResult minSplitPoint = makeComposedFoldedAffineMin(
+  OpFoldResult minSplitPoint = affine::makeComposedFoldedAffineMin(
       rewriter, op.getLoc(),
       AffineMap::inferFromExprList(ArrayRef<AffineExpr>{d0, d1 + d2}).front(),
       {splitPoint, offsets[dimension], sizes[dimension]});
 
   // Compute the size of the second part. Return early if the second part would
   // have an empty iteration space.
-  OpFoldResult remainingSize = makeComposedFoldedAffineApply(
+  OpFoldResult remainingSize = affine::makeComposedFoldedAffineApply(
       rewriter, op.getLoc(), d0 + d1 - d2,
       {iterationSpace[dimension].offset, iterationSpace[dimension].size,
        minSplitPoint});
   if (auto attr = remainingSize.dyn_cast<Attribute>()) {
     if (attr.cast<IntegerAttr>().getValue().isZero())
       return {op, TilingInterface()};
   }
 
linalg::splitOp(RewriterBase &rewriter, TilingInterface op, unsigned dimension,
   rewriter.updateRootInPlace(op, [&]() {
     unsigned numTotalOperands = op->getNumOperands();
     unsigned numOutputOperands = firstResults.size();
     op->setOperands(numTotalOperands - numOutputOperands, numOutputOperands,
                     firstResults);
   });
 
   // Create the second part.
-  OpFoldResult totalOffset = makeComposedFoldedAffineApply(
+  OpFoldResult totalOffset = affine::makeComposedFoldedAffineApply(
       rewriter, op.getLoc(), d0 + d1, {offsets[dimension], minSplitPoint});
   SmallVector<Value> secondResults;
   TilingInterface secondPart =
       createSplitPart(rewriter, op.getLoc(), op, offsets, sizes, firstResults,
                       dimension, remainingSize, totalOffset, secondResults);
 
   // Propagate any errors in part creation.
   if (!firstPart || !secondPart)
     return {TilingInterface(), TilingInterface()};
 
   // Replace the original op with the results of the two newly created ops.
   rewriter.replaceOp(op, secondResults);
   return {firstPart, secondPart};
 }

mlir/lib/Dialect/Linalg/Transforms/Tiling.cpp

 #include <utility>
 
 namespace mlir {
 #define GEN_PASS_DEF_LINALGTILINGPASS
 #include "mlir/Dialect/Linalg/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
+using namespace mlir::affine;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
 #define DEBUG_TYPE "linalg-tiling"
 
 static bool isZero(OpFoldResult v) {
   if (!v)
     return false;
mlir::linalg::computeMultiTileSizes(OpBuilder &builder, LinalgOp op,
   Value tripCount =
       getValueOrCreateConstantIndexOp(b, op.getLoc(), loopRanges[dimension]);
 
   // Compute the tile sizes and the respective numbers of tiles.
   AffineExpr s0 = b.getAffineSymbolExpr(0);
   AffineExpr s1 = b.getAffineSymbolExpr(1);
   AffineExpr s2 = b.getAffineSymbolExpr(2);
   auto apply = [&](AffineExpr expr, ValueRange values) -> Value {
-    return makeComposedAffineApply(b, b.getLoc(), expr, values);
+    return affine::makeComposedAffineApply(b, b.getLoc(), expr, values);
   };
   Value a = apply(s0.floorDiv(s1), {tripCount, divisorValue});
   Value t = apply((s0 + s1 - 1).floorDiv(s1), {targetSizeValue, divisorValue});
   Value d = apply((s0 + s1 - 1).floorDiv(s1), {a, t});
   Value s = apply(s0.floorDiv(s1) * s2, {a, d, divisorValue});
   Value v = apply(s0 % s1, {a, d});
   Value u = apply(s0 - s1, {d, v});
 
static bool canOmitTileOffsetInBoundsCheck(OpFoldResult tileSize,
   if (!tileSizeConst || !numThreadsConst || !iterSizeConst)
     return false;
   return *tileSizeConst * (*numThreadsConst - 1) < *iterSizeConst;
 }
 
 /// Build an `affine_max` of all the `vals`.
 static OpFoldResult buildMax(OpBuilder &b, Location loc,
                              ArrayRef<OpFoldResult> vals) {
-  return makeComposedFoldedAffineMax(
+  return affine::makeComposedFoldedAffineMax(
       b, loc, AffineMap::getMultiDimIdentityMap(vals.size(), loc.getContext()),
       vals);
 }
 
 /// Build an `affine_min` of all the `vals`.
 static OpFoldResult buildMin(OpBuilder &b, Location loc,
                              ArrayRef<OpFoldResult> vals) {
-  return makeComposedFoldedAffineMin(
+  return affine::makeComposedFoldedAffineMin(
       b, loc, AffineMap::getMultiDimIdentityMap(vals.size(), loc.getContext()),
       vals);
 }
 
 /// Fill out the `tiledOffsets` and `tiledSizes` to be used to tile to a given
 /// number of threads.
 static void calculateTileOffsetsAndSizes(
     RewriterBase &b, Location loc, scf::ForallOp forallOp,
mlir::linalg::getLinalgTilingCanonicalizationPatterns(MLIRContext *ctx) {
   RewritePatternSet patterns(ctx);
   populateLinalgTilingCanonicalizationPatterns(patterns);
   return patterns;
 }
 
 void mlir::linalg::populateLinalgTilingCanonicalizationPatterns(
     RewritePatternSet &patterns) {
   auto *ctx = patterns.getContext();
-  AffineApplyOp::getCanonicalizationPatterns(patterns, ctx);
-  AffineForOp::getCanonicalizationPatterns(patterns, ctx);
-  AffineMinOp::getCanonicalizationPatterns(patterns, ctx);
-  AffineMaxOp::getCanonicalizationPatterns(patterns, ctx);
+  affine::AffineApplyOp::getCanonicalizationPatterns(patterns, ctx);
+  affine::AffineForOp::getCanonicalizationPatterns(patterns, ctx);
+  affine::AffineMinOp::getCanonicalizationPatterns(patterns, ctx);
+  affine::AffineMaxOp::getCanonicalizationPatterns(patterns, ctx);
   arith::ConstantIndexOp::getCanonicalizationPatterns(patterns, ctx);
 
   memref::SubViewOp::getCanonicalizationPatterns(patterns, ctx);
   memref::ViewOp::getCanonicalizationPatterns(patterns, ctx);
 
   scf::ForOp::getCanonicalizationPatterns(patterns, ctx);
   scf::ParallelOp::getCanonicalizationPatterns(patterns, ctx);
 

mlir/lib/Dialect/Linalg/Transforms/TilingInterfaceImpl.cpp

 static SmallVector<Value> getIndicesForAccess(OpBuilder &b, Location loc,
                                               AffineMap indexingMap,
                                               ValueRange ivs) {
   SmallVector<Value> indices;
   indices.reserve(indexingMap.getNumResults());
   for (auto result : indexingMap.getResults()) {
     AffineMap m = AffineMap::get(indexingMap.getNumDims(),
                                  indexingMap.getNumSymbols(), result);
-    Value v = b.create<AffineApplyOp>(loc, m, ivs);
+    Value v = b.create<affine::AffineApplyOp>(loc, m, ivs);
     indices.push_back(v);
   }
   return indices;
 }
 
 /// Method to inline the payload of a `linalgOp` given the iteration space
 /// point and values for the arguments of the payload.
 static LogicalResult inlinePayload(OpBuilder &b, LinalgOp linalgOp,
SmallVector<Range> getIterationDomain(Operation *op, OpBuilder &b) const {
     Location loc = op->getLoc();
     LinalgOp linalgOp = cast<LinalgOp>(op);
     SmallVector<OpFoldResult> allShapesSizes =
         linalgOp.createFlatListOfOperandDims(b, loc);
     AffineMap map = linalgOp.getShapesToLoopsMap();
 
     return llvm::to_vector(
         llvm::map_range(map.getResults(), [&](AffineExpr loopExpr) {
-          OpFoldResult ofr =
-              makeComposedFoldedAffineApply(b, loc, loopExpr, allShapesSizes);
+          OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
+              b, loc, loopExpr, allShapesSizes);
           return Range{b.getIndexAttr(0), ofr, b.getIndexAttr(1)};
         }));
   }
 
   // Instantiate the tiled implementation of the operation.
   FailureOr<TilingResult>
   getTiledImplementation(Operation *op, OpBuilder &b,
                          ArrayRef<OpFoldResult> offsets,
getResultTilePosition(Operation *op, OpBuilder &b, unsigned resultNumber,
                         SmallVector<OpFoldResult> &resultSizes) const {
     Location loc = op->getLoc();
     LinalgOp linalgOp = cast<LinalgOp>(op);
 
     AffineExpr d0;
     bindDims(b.getContext(), d0);
     SmallVector<OpFoldResult> subShapeSizes =
         llvm::to_vector(llvm::map_range(sizes, [&](OpFoldResult ofr) {
-          return makeComposedFoldedAffineApply(b, loc, d0 - 1, ofr);
+          return affine::makeComposedFoldedAffineApply(b, loc, d0 - 1, ofr);
         }));
 
     OpOperand *outOperand = linalgOp.getDpsInitOperand(resultNumber);
     SliceParameters sliceParams = computeSliceParameters(
         b, loc, outOperand->get(), sizes,
         linalgOp.getMatchingIndexingMap(outOperand), offsets,
         /*ubs*/ {}, subShapeSizes, true);
     resultOffsets = sliceParams.offsets;

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

if (failed(reductionPreconditions(linalgOp))) {
     return failure();
   }
   return success();
 }
 
 /// Converts affine.apply Ops to arithmetic operations.
 static void convertAffineApply(RewriterBase &rewriter, LinalgOp linalgOp) {
   OpBuilder::InsertionGuard g(rewriter);
-  auto toReplace = linalgOp.getBlock()->getOps<AffineApplyOp>();
+  auto toReplace = linalgOp.getBlock()->getOps<affine::AffineApplyOp>();
 
   for (auto op : make_early_inc_range(toReplace)) {
     rewriter.setInsertionPoint(op);
-    auto expanded = expandAffineExpr(
+    auto expanded = affine::expandAffineExpr(
         rewriter, op->getLoc(), op.getAffineMap().getResult(0),
         op.getOperands().take_front(op.getAffineMap().getNumDims()),
         op.getOperands().take_back(op.getAffineMap().getNumSymbols()));
     rewriter.replaceOp(op, expanded);
   }
 }
 
 FailureOr<vector::TransferWriteOp>
for (unsigned i = 0; i < t1.getRank(); ++i) {
       // Other cases: Take a deeper look at defining ops of values.
       auto v1 = size1.dyn_cast<Value>();
       auto v2 = size2.dyn_cast<Value>();
       if (!v1 || !v2)
         return false;
 
       // Case 2: Both values are identical AffineMinOps. (Should not happen if
       // CSE is run.)
-      auto minOp1 = v1.getDefiningOp<AffineMinOp>();
-      auto minOp2 = v2.getDefiningOp<AffineMinOp>();
+      auto minOp1 = v1.getDefiningOp<affine::AffineMinOp>();
+      auto minOp2 = v2.getDefiningOp<affine::AffineMinOp>();
       if (minOp1 && minOp2 && minOp1.getAffineMap() == minOp2.getAffineMap() &&
           minOp1.getOperands() == minOp2.getOperands())
         continue;
 
       // Add additional cases as needed.
     }
 
     // All tests passed.

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 #define DEBUG_TYPE "linalg-utils"
 
 using namespace mlir;
 using namespace presburger;
+using namespace mlir::affine;
 using namespace mlir::linalg;
 using namespace mlir::scf;
 
 namespace {
 
 // Helper visitor to determine whether an AffineExpr is tiled.
 // This is achieved by traversing every AffineDimExpr with position `pos` and
 // checking whether the corresponding `tileSizes[pos]` is non-zero.
void GenerateLoopNest<AffineForOp>::doit(
   SmallVector<int64_t, 4> constantSteps;
   constantSteps.reserve(steps.size());
   for (Value v : steps) {
     auto op = v.getDefiningOp<arith::ConstantIndexOp>();
     assert(op && "Affine loops require constant steps");
     constantSteps.push_back(op.value());
   }
 
-  mlir::buildAffineLoopNest(b, loc, lbs, ubs, constantSteps,
+  affine::buildAffineLoopNest(b, loc, lbs, ubs, constantSteps,
                               [&](OpBuilder &b, Location loc, ValueRange ivs) {
                                 bodyBuilderFn(b, loc, ivs,
                                               linalgOp->getOperands());
                               });
 }
 
 /// Update the `lb`, `ub` and `step` to get per processor `lb`, `ub` and `step`.
 void updateBoundsForCyclicDistribution(OpBuilder &b, Location loc, Value procId,
                                        Value nprocs, Value &lb, Value &ub,
                                        Value &step) {
   AffineExpr d0, d1;
   bindDims(b.getContext(), d0, d1);
   AffineExpr s0 = getAffineSymbolExpr(0, b.getContext());
-  lb = makeComposedAffineApply(b, loc, d0 + d1 * s0, {lb, procId, step});
-  step = makeComposedAffineApply(b, loc, d0 * s0, {nprocs, step});
+  lb =
+      affine::makeComposedAffineApply(b, loc, d0 + d1 * s0, {lb, procId, step});
+  step = affine::makeComposedAffineApply(b, loc, d0 * s0, {nprocs, step});
 }
 
 /// Generates a loop nest consisting of scf.parallel and scf.for, depending
 /// on the `iteratorTypes.` Consecutive parallel loops create a single
 /// scf.parallel operation; each sequential loop creates a new scf.for
 /// operation. The body of the innermost loop is populated by
 /// `bodyBuilderFn` that accepts a range of induction variables for all
 /// loops. `ivStorage` is used to store the partial list of induction

mlir/lib/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp

 class MemRefTransformDialectExtension
     : public transform::TransformDialectExtension<
           MemRefTransformDialectExtension> {
 public:
   using Base::Base;
 
   void init() {
     declareDependentDialect<pdl::PDLDialect>();
-    declareGeneratedDialect<AffineDialect>();
+    declareGeneratedDialect<affine::AffineDialect>();
     declareGeneratedDialect<arith::ArithDialect>();
     declareGeneratedDialect<memref::MemRefDialect>();
     declareGeneratedDialect<nvgpu::NVGPUDialect>();
     declareGeneratedDialect<vector::VectorDialect>();
 
     registerTransformOps<
 #define GET_OP_LIST
 #include "mlir/Dialect/MemRef/TransformOps/MemRefTransformOps.cpp.inc"

mlir/lib/Dialect/MemRef/Transforms/ComposeSubView.cpp

for (auto it : llvm::zip(op.getMixedOffsets(), sourceOp.getMixedOffsets(),
           } else {
             expr =
                 expr + rewriter.getAffineSymbolExpr(affineApplyOperands.size());
             affineApplyOperands.push_back(valueOrAttr.get<Value>());
           }
         }
 
         AffineMap map = AffineMap::get(0, affineApplyOperands.size(), expr);
-        Value result = rewriter.create<AffineApplyOp>(op.getLoc(), map,
-                                                      affineApplyOperands);
+        Value result = rewriter.create<affine::AffineApplyOp>(
+            op.getLoc(), map, affineApplyOperands);
         offsets.push_back(result);
       }
     }
 
     // This replaces 'op' but leaves 'sourceOp' alone; if it no longer has any
     // uses it can be removed by a (separate) dead code elimination pass.
     rewriter.replaceOpWithNewOp<memref::SubViewOp>(op, sourceOp.getSource(),
                                                    offsets, sizes, strides);

mlir/lib/Dialect/MemRef/Transforms/ExpandStridedMetadata.cpp

 #include <optional>
 
 namespace mlir {
 namespace memref {
 #define GEN_PASS_DEF_EXPANDSTRIDEDMETADATA
 #include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
 } // namespace memref
 } // namespace mlir
+
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 struct StridedMetadata {
   Value basePtr;
   OpFoldResult offset;
   SmallVector<OpFoldResult> sizes;
   SmallVector<OpFoldResult> strides;

mlir/lib/Dialect/MemRef/Transforms/ExtractAddressComputations.cpp

getGenericOpViewSizeForEachDim(RewriterBase &rewriter,
   SmallVector<OpFoldResult> indices =
       getAsOpFoldResult(loadStoreLikeOp.getIndices());
   SmallVector<OpFoldResult> finalSizes;
 
   AffineExpr s0 = rewriter.getAffineSymbolExpr(0);
   AffineExpr s1 = rewriter.getAffineSymbolExpr(1);
 
   for (auto [srcSize, indice] : llvm::zip(srcSizes, indices)) {
-    finalSizes.push_back(makeComposedFoldedAffineApply(rewriter, loc, s0 - s1,
-                                                       {srcSize, indice}));
+    finalSizes.push_back(affine::makeComposedFoldedAffineApply(
+        rewriter, loc, s0 - s1, {srcSize, indice}));
   }
   return finalSizes;
 }
 
 /// Rewrite a store/load-like op so that all its indices are zeros.
 /// E.g., %ld = memref.load %base[%off0]...[%offN]
 /// =>
 /// %new_base = subview %base[%off0,.., %offN][1,..,1][1,..,1]

mlir/lib/Dialect/MemRef/Transforms/FoldMemRefAliasOps.cpp

for (ArrayRef<int64_t> groups : expandShapeOp.getReassociationIndices()) {
 
     /// Apply permutation and create AffineApplyOp.
     SmallVector<OpFoldResult> dynamicIndices(groupSize);
     for (int64_t i = 0; i < groupSize; i++)
       dynamicIndices[i] = indices[groups[i]];
 
     // Creating maximally folded and composd affine.apply composes better with
     // other transformations without interleaving canonicalization passes.
-    OpFoldResult ofr = makeComposedFoldedAffineApply(
+    OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
         rewriter, loc,
         AffineMap::get(/*numDims=*/groupSize,
                        /*numSymbols=*/0, srcIndexExpr),
         dynamicIndices);
     sourceIndices.push_back(
         getValueOrCreateConstantIndexOp(rewriter, loc, ofr));
   }
   return success();
for (ArrayRef<int64_t> groups : collapseShapeOp.getReassociationIndices()) {
 
     // Derive the index values along all dimensions of the source corresponding
     // to the index wrt to collapsed shape op output.
     auto d0 = rewriter.getAffineDimExpr(0);
     SmallVector<AffineExpr> delinearizingExprs = delinearize(d0, suffixProduct);
 
     // Construct the AffineApplyOp for each delinearizingExpr.
     for (int64_t i = 0; i < groupSize; i++) {
-      OpFoldResult ofr = makeComposedFoldedAffineApply(
+      OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
           rewriter, loc,
           AffineMap::get(/*numDims=*/1, /*numSymbols=*/0,
                          delinearizingExprs[i]),
           dynamicIndices);
       sourceIndices.push_back(
           getValueOrCreateConstantIndexOp(rewriter, loc, ofr));
     }
     dynamicIndices.clear();
   }
   if (collapseShapeOp.getReassociationIndices().empty()) {
     auto zeroAffineMap = rewriter.getConstantAffineMap(0);
     int64_t srcRank =
         collapseShapeOp.getViewSource().getType().cast<MemRefType>().getRank();
     for (int64_t i = 0; i < srcRank; i++) {
-      OpFoldResult ofr = makeComposedFoldedAffineApply(
+      OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
           rewriter, loc, zeroAffineMap, dynamicIndices);
       sourceIndices.push_back(
           getValueOrCreateConstantIndexOp(rewriter, loc, ofr));
     }
   }
   return success();
 }
 
LogicalResult matchAndRewrite(memref::SubViewOp subView,
     }
     if (!srcSubView.hasUnitStride()) {
       return rewriter.notifyMatchFailure(srcSubView, "requires unit strides");
     }
 
     // Resolve sizes according to dropped dims.
     SmallVector<OpFoldResult> resolvedSizes;
     llvm::SmallBitVector srcDroppedDims = srcSubView.getDroppedDims();
-    resolveSizesIntoOpWithSizes(srcSubView.getMixedSizes(),
+    affine::resolveSizesIntoOpWithSizes(srcSubView.getMixedSizes(),
                                         subView.getMixedSizes(), srcDroppedDims,
                                         resolvedSizes);
 
     // Resolve offsets according to source offsets and strides.
     SmallVector<Value> resolvedOffsets;
-    resolveIndicesIntoOpWithOffsetsAndStrides(
+    affine::resolveIndicesIntoOpWithOffsetsAndStrides(
         rewriter, subView.getLoc(), srcSubView.getMixedOffsets(),
         srcSubView.getMixedStrides(), srcDroppedDims, subView.getMixedOffsets(),
         resolvedOffsets);
 
     // Replace original op.
     rewriter.replaceOpWithNewOp<memref::SubViewOp>(
         subView, subView.getType(), srcSubView.getSource(),
         getAsOpFoldResult(resolvedOffsets), resolvedSizes,
         srcSubView.getMixedStrides());
 
     return success();
   }
 };
 } // namespace
 
 static SmallVector<Value>
 calculateExpandedAccessIndices(AffineMap affineMap,
                                const SmallVector<Value> &indices, Location loc,
                                PatternRewriter &rewriter) {
   SmallVector<OpFoldResult> indicesOfr(llvm::to_vector(
       llvm::map_range(indices, [](Value v) -> OpFoldResult { return v; })));
   SmallVector<Value> expandedIndices;
   for (unsigned i = 0, e = affineMap.getNumResults(); i < e; i++) {
-    OpFoldResult ofr = makeComposedFoldedAffineApply(
+    OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
         rewriter, loc, affineMap.getSubMap({i}), indicesOfr);
     expandedIndices.push_back(
         getValueOrCreateConstantIndexOp(rewriter, loc, ofr));
   }
   return expandedIndices;
 }
 
 template <typename XferOp>
LogicalResult preconditionResult =
       preconditionsFoldSubViewOp(rewriter, loadOp, subViewOp);
   if (failed(preconditionResult))
     return preconditionResult;
 
   SmallVector<Value> indices(loadOp.getIndices().begin(),
                              loadOp.getIndices().end());
   // For affine ops, we need to apply the map to get the operands to get the
   // "actual" indices.
-  if (auto affineLoadOp = dyn_cast<AffineLoadOp>(loadOp.getOperation())) {
+  if (auto affineLoadOp =
+          dyn_cast<affine::AffineLoadOp>(loadOp.getOperation())) {
     AffineMap affineMap = affineLoadOp.getAffineMap();
     auto expandedIndices = calculateExpandedAccessIndices(
         affineMap, indices, loadOp.getLoc(), rewriter);
     indices.assign(expandedIndices.begin(), expandedIndices.end());
   }
   SmallVector<Value> sourceIndices;
-  resolveIndicesIntoOpWithOffsetsAndStrides(
+  affine::resolveIndicesIntoOpWithOffsetsAndStrides(
       rewriter, loadOp.getLoc(), subViewOp.getMixedOffsets(),
       subViewOp.getMixedStrides(), subViewOp.getDroppedDims(), indices,
       sourceIndices);
 
   llvm::TypeSwitch<Operation *, void>(loadOp)
-      .Case([&](AffineLoadOp op) {
-        rewriter.replaceOpWithNewOp<AffineLoadOp>(loadOp, subViewOp.getSource(),
-                                                  sourceIndices);
+      .Case([&](affine::AffineLoadOp op) {
+        rewriter.replaceOpWithNewOp<affine::AffineLoadOp>(
+            loadOp, subViewOp.getSource(), sourceIndices);
       })
       .Case([&](memref::LoadOp op) {
         rewriter.replaceOpWithNewOp<memref::LoadOp>(
             loadOp, subViewOp.getSource(), sourceIndices, op.getNontemporal());
       })
       .Case([&](vector::TransferReadOp op) {
         rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
             op, op.getVectorType(), subViewOp.getSource(), sourceIndices,
LogicalResult LoadOpOfExpandShapeOpFolder<OpTy>::matchAndRewrite(
 
   if (!expandShapeOp)
     return failure();
 
   SmallVector<Value> indices(loadOp.getIndices().begin(),
                              loadOp.getIndices().end());
   // For affine ops, we need to apply the map to get the operands to get the
   // "actual" indices.
-  if (auto affineLoadOp = dyn_cast<AffineLoadOp>(loadOp.getOperation())) {
+  if (auto affineLoadOp =
+          dyn_cast<affine::AffineLoadOp>(loadOp.getOperation())) {
     AffineMap affineMap = affineLoadOp.getAffineMap();
     auto expandedIndices = calculateExpandedAccessIndices(
         affineMap, indices, loadOp.getLoc(), rewriter);
     indices.assign(expandedIndices.begin(), expandedIndices.end());
   }
   SmallVector<Value> sourceIndices;
   if (failed(resolveSourceIndicesExpandShape(
           loadOp.getLoc(), rewriter, expandShapeOp, indices, sourceIndices)))
     return failure();
   llvm::TypeSwitch<Operation *, void>(loadOp)
-      .Case<AffineLoadOp, memref::LoadOp>([&](auto op) {
+      .Case<affine::AffineLoadOp, memref::LoadOp>([&](auto op) {
         rewriter.replaceOpWithNewOp<decltype(op)>(
             loadOp, expandShapeOp.getViewSource(), sourceIndices);
       })
       .Default([](Operation *) { llvm_unreachable("unexpected operation."); });
   return success();
 }
 
 template <typename OpTy>
 LogicalResult LoadOpOfCollapseShapeOpFolder<OpTy>::matchAndRewrite(
     OpTy loadOp, PatternRewriter &rewriter) const {
   auto collapseShapeOp = getMemRefOperand(loadOp)
                              .template getDefiningOp<memref::CollapseShapeOp>();
 
   if (!collapseShapeOp)
     return failure();
 
   SmallVector<Value> indices(loadOp.getIndices().begin(),
                              loadOp.getIndices().end());
   // For affine ops, we need to apply the map to get the operands to get the
   // "actual" indices.
-  if (auto affineLoadOp = dyn_cast<AffineLoadOp>(loadOp.getOperation())) {
+  if (auto affineLoadOp =
+          dyn_cast<affine::AffineLoadOp>(loadOp.getOperation())) {
     AffineMap affineMap = affineLoadOp.getAffineMap();
     auto expandedIndices = calculateExpandedAccessIndices(
         affineMap, indices, loadOp.getLoc(), rewriter);
     indices.assign(expandedIndices.begin(), expandedIndices.end());
   }
   SmallVector<Value> sourceIndices;
   if (failed(resolveSourceIndicesCollapseShape(
           loadOp.getLoc(), rewriter, collapseShapeOp, indices, sourceIndices)))
     return failure();
   llvm::TypeSwitch<Operation *, void>(loadOp)
-      .Case<AffineLoadOp, memref::LoadOp>([&](auto op) {
+      .Case<affine::AffineLoadOp, memref::LoadOp>([&](auto op) {
         rewriter.replaceOpWithNewOp<decltype(op)>(
             loadOp, collapseShapeOp.getViewSource(), sourceIndices);
       })
       .Default([](Operation *) { llvm_unreachable("unexpected operation."); });
   return success();
 }
 
 template <typename OpTy>
LogicalResult preconditionResult =
       preconditionsFoldSubViewOp(rewriter, storeOp, subViewOp);
   if (failed(preconditionResult))
     return preconditionResult;
 
   SmallVector<Value> indices(storeOp.getIndices().begin(),
                              storeOp.getIndices().end());
   // For affine ops, we need to apply the map to get the operands to get the
   // "actual" indices.
-  if (auto affineStoreOp = dyn_cast<AffineStoreOp>(storeOp.getOperation())) {
+  if (auto affineStoreOp =
+          dyn_cast<affine::AffineStoreOp>(storeOp.getOperation())) {
     AffineMap affineMap = affineStoreOp.getAffineMap();
     auto expandedIndices = calculateExpandedAccessIndices(
         affineMap, indices, storeOp.getLoc(), rewriter);
     indices.assign(expandedIndices.begin(), expandedIndices.end());
   }
   SmallVector<Value> sourceIndices;
-  resolveIndicesIntoOpWithOffsetsAndStrides(
+  affine::resolveIndicesIntoOpWithOffsetsAndStrides(
       rewriter, storeOp.getLoc(), subViewOp.getMixedOffsets(),
       subViewOp.getMixedStrides(), subViewOp.getDroppedDims(), indices,
       sourceIndices);
 
   llvm::TypeSwitch<Operation *, void>(storeOp)
-      .Case([&](AffineStoreOp op) {
-        rewriter.replaceOpWithNewOp<AffineStoreOp>(
+      .Case([&](affine::AffineStoreOp op) {
+        rewriter.replaceOpWithNewOp<affine::AffineStoreOp>(
             op, op.getValue(), subViewOp.getSource(), sourceIndices);
       })
       .Case([&](memref::StoreOp op) {
         rewriter.replaceOpWithNewOp<memref::StoreOp>(
             op, op.getValue(), subViewOp.getSource(), sourceIndices,
             op.getNontemporal());
       })
       .Case([&](vector::TransferWriteOp op) {
LogicalResult StoreOpOfExpandShapeOpFolder<OpTy>::matchAndRewrite(
 
   if (!expandShapeOp)
     return failure();
 
   SmallVector<Value> indices(storeOp.getIndices().begin(),
                              storeOp.getIndices().end());
   // For affine ops, we need to apply the map to get the operands to get the
   // "actual" indices.
-  if (auto affineStoreOp = dyn_cast<AffineStoreOp>(storeOp.getOperation())) {
+  if (auto affineStoreOp =
+          dyn_cast<affine::AffineStoreOp>(storeOp.getOperation())) {
     AffineMap affineMap = affineStoreOp.getAffineMap();
     auto expandedIndices = calculateExpandedAccessIndices(
         affineMap, indices, storeOp.getLoc(), rewriter);
     indices.assign(expandedIndices.begin(), expandedIndices.end());
   }
   SmallVector<Value> sourceIndices;
   if (failed(resolveSourceIndicesExpandShape(
           storeOp.getLoc(), rewriter, expandShapeOp, indices, sourceIndices)))
     return failure();
   llvm::TypeSwitch<Operation *, void>(storeOp)
-      .Case<AffineStoreOp, memref::StoreOp>([&](auto op) {
+      .Case<affine::AffineStoreOp, memref::StoreOp>([&](auto op) {
         rewriter.replaceOpWithNewOp<decltype(op)>(storeOp, storeOp.getValue(),
                                                   expandShapeOp.getViewSource(),
                                                   sourceIndices);
       })
       .Default([](Operation *) { llvm_unreachable("unexpected operation."); });
   return success();
 }
 
 template <typename OpTy>
 LogicalResult StoreOpOfCollapseShapeOpFolder<OpTy>::matchAndRewrite(
     OpTy storeOp, PatternRewriter &rewriter) const {
   auto collapseShapeOp = getMemRefOperand(storeOp)
                              .template getDefiningOp<memref::CollapseShapeOp>();
 
   if (!collapseShapeOp)
     return failure();
 
   SmallVector<Value> indices(storeOp.getIndices().begin(),
                              storeOp.getIndices().end());
   // For affine ops, we need to apply the map to get the operands to get the
   // "actual" indices.
-  if (auto affineStoreOp = dyn_cast<AffineStoreOp>(storeOp.getOperation())) {
+  if (auto affineStoreOp =
+          dyn_cast<affine::AffineStoreOp>(storeOp.getOperation())) {
     AffineMap affineMap = affineStoreOp.getAffineMap();
     auto expandedIndices = calculateExpandedAccessIndices(
         affineMap, indices, storeOp.getLoc(), rewriter);
     indices.assign(expandedIndices.begin(), expandedIndices.end());
   }
   SmallVector<Value> sourceIndices;
   if (failed(resolveSourceIndicesCollapseShape(
           storeOp.getLoc(), rewriter, collapseShapeOp, indices, sourceIndices)))
     return failure();
   llvm::TypeSwitch<Operation *, void>(storeOp)
-      .Case<AffineStoreOp, memref::StoreOp>([&](auto op) {
+      .Case<affine::AffineStoreOp, memref::StoreOp>([&](auto op) {
         rewriter.replaceOpWithNewOp<decltype(op)>(
             storeOp, storeOp.getValue(), collapseShapeOp.getViewSource(),
             sourceIndices);
       })
       .Default([](Operation *) { llvm_unreachable("unexpected operation."); });
   return success();
 }
 
 void memref::populateFoldMemRefAliasOpPatterns(RewritePatternSet &patterns) {
-  patterns.add<LoadOpOfSubViewOpFolder<AffineLoadOp>,
+  patterns.add<LoadOpOfSubViewOpFolder<affine::AffineLoadOp>,
                LoadOpOfSubViewOpFolder<memref::LoadOp>,
                LoadOpOfSubViewOpFolder<vector::TransferReadOp>,
                LoadOpOfSubViewOpFolder<gpu::SubgroupMmaLoadMatrixOp>,
-               StoreOpOfSubViewOpFolder<AffineStoreOp>,
+               StoreOpOfSubViewOpFolder<affine::AffineStoreOp>,
                StoreOpOfSubViewOpFolder<memref::StoreOp>,
                StoreOpOfSubViewOpFolder<vector::TransferWriteOp>,
                StoreOpOfSubViewOpFolder<gpu::SubgroupMmaStoreMatrixOp>,
-               LoadOpOfExpandShapeOpFolder<AffineLoadOp>,
+               LoadOpOfExpandShapeOpFolder<affine::AffineLoadOp>,
                LoadOpOfExpandShapeOpFolder<memref::LoadOp>,
-               StoreOpOfExpandShapeOpFolder<AffineStoreOp>,
+               StoreOpOfExpandShapeOpFolder<affine::AffineStoreOp>,
                StoreOpOfExpandShapeOpFolder<memref::StoreOp>,
-               LoadOpOfCollapseShapeOpFolder<AffineLoadOp>,
+               LoadOpOfCollapseShapeOpFolder<affine::AffineLoadOp>,
                LoadOpOfCollapseShapeOpFolder<memref::LoadOp>,
-               StoreOpOfCollapseShapeOpFolder<AffineStoreOp>,
+               StoreOpOfCollapseShapeOpFolder<affine::AffineStoreOp>,
                StoreOpOfCollapseShapeOpFolder<memref::StoreOp>,
                SubViewOfSubViewFolder>(patterns.getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // Pass registration
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/MemRef/Transforms/MultiBuffer.cpp

mlir::memref::multiBuffer(RewriterBase &rewriter, memref::AllocOp allocOp,
   // 3. Within the loop, build the modular leading index (i.e. each loop
   // iteration %iv accesses slice ((%iv - %lb) / %step) % %mb_factor).
   rewriter.setInsertionPointToStart(&candidateLoop.getLoopBody().front());
   Value ivVal = *inductionVar;
   Value lbVal = getValueOrCreateConstantIndexOp(rewriter, loc, *lowerBound);
   Value stepVal = getValueOrCreateConstantIndexOp(rewriter, loc, *singleStep);
   AffineExpr iv, lb, step;
   bindDims(rewriter.getContext(), iv, lb, step);
-  Value bufferIndex = makeComposedAffineApply(
+  Value bufferIndex = affine::makeComposedAffineApply(
       rewriter, loc, ((iv - lb).floorDiv(step)) % multiBufferingFactor,
       {ivVal, lbVal, stepVal});
   LLVM_DEBUG(DBGS() << "--multi-buffered indexing: " << bufferIndex << "\n");
 
   // 4. Build the subview accessing the particular slice, taking modular
   // rotation into account.
   int64_t mbMemRefTypeRank = mbMemRefType.getRank();
   IntegerAttr zero = rewriter.getIndexAttr(0);

mlir/lib/Dialect/MemRef/Transforms/NormalizeMemRefs.cpp

 #define GEN_PASS_DEF_NORMALIZEMEMREFS
 #include "mlir/Dialect/MemRef/Transforms/Passes.h.inc"
 } // namespace memref
 } // namespace mlir
 
 #define DEBUG_TYPE "normalize-memrefs"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// All memrefs passed across functions with non-trivial layout maps are
 /// converted to ones with trivial identity layout ones.
 /// If all the memref types/uses in a function are normalizable, we treat
 /// such functions as normalizable. Also, if a normalizable function is known
 /// to call a non-normalizable function, we treat that function as

mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp

 #include "mlir/Dialect/SCF/Transforms/Transforms.h"
 #include "mlir/Dialect/SCF/Utils/Utils.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
 #include "mlir/Dialect/Transform/IR/TransformInterfaces.h"
 #include "mlir/Dialect/Transform/IR/TransformOps.h"
 #include "mlir/Dialect/Vector/IR/VectorOps.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 //===----------------------------------------------------------------------===//
 // GetParentForOp
 //===----------------------------------------------------------------------===//
 DiagnosedSilenceableFailure
 transform::GetParentForOp::apply(transform::TransformResults &results,
                                  transform::TransformState &state) {
   SetVector<Operation *> parents;

 namespace {
 class SCFTransformDialectExtension
     : public transform::TransformDialectExtension<
           SCFTransformDialectExtension> {
 public:
   using Base::Base;
 
   void init() {
-    declareGeneratedDialect<AffineDialect>();
+    declareGeneratedDialect<affine::AffineDialect>();
     declareGeneratedDialect<func::FuncDialect>();
 
     registerTransformOps<
 #define GET_OP_LIST
 #include "mlir/Dialect/SCF/TransformOps/SCFTransformOps.cpp.inc"
         >();
   }
 };
 } // namespace
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SCF/TransformOps/SCFTransformOps.cpp.inc"
 
 void mlir::scf::registerTransformDialectExtension(DialectRegistry &registry) {
   registry.addExtensions<SCFTransformDialectExtension>();
 }

mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp

struct SCFForLoopCanonicalization
   }
 };
 } // namespace
 
 void mlir::scf::populateSCFForLoopCanonicalizationPatterns(
     RewritePatternSet &patterns) {
   MLIRContext *ctx = patterns.getContext();
   patterns
-      .add<AffineOpSCFCanonicalizationPattern<AffineMinOp>,
-           AffineOpSCFCanonicalizationPattern<AffineMaxOp>,
+      .add<AffineOpSCFCanonicalizationPattern<affine::AffineMinOp>,
+           AffineOpSCFCanonicalizationPattern<affine::AffineMaxOp>,
            DimOfIterArgFolder<tensor::DimOp>, DimOfIterArgFolder<memref::DimOp>,
            DimOfLoopResultFolder<tensor::DimOp>,
            DimOfLoopResultFolder<memref::DimOp>>(ctx);
 }
 
 std::unique_ptr<Pass> mlir::createSCFForLoopCanonicalizationPass() {
   return std::make_unique<SCFForLoopCanonicalization>();
 }

mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp

 namespace mlir {
 #define GEN_PASS_DEF_SCFFORLOOPPEELING
 #define GEN_PASS_DEF_SCFFORLOOPSPECIALIZATION
 #define GEN_PASS_DEF_SCFPARALLELLOOPSPECIALIZATION
 #include "mlir/Dialect/SCF/Transforms/Passes.h.inc"
 } // namespace mlir
 
 using namespace mlir;
+using namespace mlir::affine;
 using scf::ForOp;
 using scf::ParallelOp;
 
 /// Rewrite a parallel loop with bounds defined by an affine.min with a constant
 /// into 2 loops after checking if the bounds are equal to that constant. This
 /// is beneficial if the loop will almost always have the constant bound and
 /// that version can be fully unrolled and vectorized.
 static void specializeParallelLoopForUnrolling(ParallelOp op) {

mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp

if (noMinMaxBounds) {
       newBounds.push_back(newStep);
       needInboundCheck = true;
       continue;
     }
 
     // Otherwise, we dynamically compute the bound for
     // each iteration of the outer loop.
     newBounds.push_back(
-        b.create<AffineMinOp>(op.getLoc(), b.getIndexType(), minMap,
+        b.create<affine::AffineMinOp>(op.getLoc(), b.getIndexType(), minMap,
                                       ValueRange{newStep, upperBound, iv}));
   }
   auto innerLoop = b.create<ParallelOp>(
       op.getLoc(), SmallVector<Value, 2>(newBounds.size(), zero), newBounds,
       op.getStep());
 
   if (noMinMaxBounds && needInboundCheck) {
     b.setInsertionPointToStart(innerLoop.getBody());
     // Insert in-bound check

mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp

static OpFoldResult getBoundedTileSize(OpBuilder &b, Location loc,
   // The tile size to use (to avoid out of bounds access) is  minimum of
   // `tileSize` and `ub - iv`, where `iv` is the induction variable of the tiled
   // loop.
   AffineExpr s0, s1, d0;
   bindDims(b.getContext(), d0);
   bindSymbols(b.getContext(), s0, s1);
   AffineMap minMap = AffineMap::get(1, 2, {s0, s1 - d0}, b.getContext());
   Value size = getValueOrCreateConstantIndexOp(b, loc, loopRange.size);
-  return makeComposedFoldedAffineMin(
+  return affine::makeComposedFoldedAffineMin(
       b, loc, minMap, SmallVector<OpFoldResult>{iv, tileSize, size});
 }
 
 /// Generate an empty loop nest that represents the tiled loop nest shell.
 /// - `loopRanges` specifies the lb, ub and step of the untiled iteration space.
 /// - `tileSizeVals` is the tile sizes to use. Zero represent untiled loops.
 /// - In `offsets` and `sizes` return the multi-dimensional offset and size of
 /// the

mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp

 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "mlir-scf-affine-utils"
 
 using namespace mlir;
+using namespace affine;
 using namespace presburger;
 
 LogicalResult scf::matchForLikeLoop(Value iv, OpFoldResult &lb,
                                     OpFoldResult &ub, OpFoldResult &step) {
   if (scf::ForOp forOp = scf::getForInductionVarOwner(iv)) {
     lb = forOp.getLowerBound();
     ub = forOp.getUpperBound();
     step = forOp.getStep();

 }
 
 static FailureOr<AffineApplyOp>
 canonicalizeMinMaxOp(RewriterBase &rewriter, Operation *op,
                      FlatAffineValueConstraints constraints) {
   RewriterBase::InsertionGuard guard(rewriter);
   rewriter.setInsertionPoint(op);
   FailureOr<AffineValueMap> simplified =
-      mlir::simplifyConstrainedMinMaxOp(op, std::move(constraints));
+      affine::simplifyConstrainedMinMaxOp(op, std::move(constraints));
   if (failed(simplified))
     return failure();
   return rewriter.replaceOpWithNewOp<AffineApplyOp>(
       op, simplified->getAffineMap(), simplified->getOperands());
 }
 
 LogicalResult scf::addLoopRangeConstraints(FlatAffineValueConstraints &cstr,
                                            Value iv, OpFoldResult lb,

mlir/lib/Dialect/SparseTensor/Transforms/SparseVectorization.cpp

static Value genVectorMask(PatternRewriter &rewriter, Location loc, VL vl,
   // during vector execution. Here we rely on subsequent loop optimizations to
   // avoid executing the mask in all iterations, for example, by splitting the
   // loop into an unconditional vector loop and a scalar cleanup loop.
   auto min = AffineMap::get(
       /*dimCount=*/2, /*symbolCount=*/1,
       {rewriter.getAffineSymbolExpr(0),
        rewriter.getAffineDimExpr(0) - rewriter.getAffineDimExpr(1)},
       rewriter.getContext());
-  Value end =
-      rewriter.createOrFold<AffineMinOp>(loc, min, ValueRange{hi, iv, step});
+  Value end = rewriter.createOrFold<affine::AffineMinOp>(
+      loc, min, ValueRange{hi, iv, step});
   return rewriter.create<vector::CreateMaskOp>(loc, mtp, end);
 }
 
 /// Generates a vectorized invariant. Here we rely on subsequent loop
 /// optimizations to hoist the invariant broadcast out of the vector loop.
 static Value genVectorInvariantValue(PatternRewriter &rewriter, VL vl,
                                      Value val) {
   VectorType vtp = vectorType(vl, val.getType());

mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp

static OpFoldResult getCollapsedOutputDimFromInputShape(
   unsigned endPos = map.getResults().back().cast<AffineDimExpr>().getPosition();
   AffineExpr expr;
   SmallVector<Value, 2> dynamicDims;
   for (auto dim : llvm::seq_inclusive(startPos, endPos)) {
     dynamicDims.push_back(builder.createOrFold<tensor::DimOp>(loc, src, dim));
     AffineExpr currExpr = builder.getAffineSymbolExpr(dim - startPos);
     expr = (expr ? expr * currExpr : currExpr);
   }
-  return applyMapToValues(builder, loc,
-                          AffineMap::get(0, endPos - startPos + 1, expr),
-                          dynamicDims)[0];
+  return affine::applyMapToValues(
+      builder, loc, AffineMap::get(0, endPos - startPos + 1, expr),
 }
 
 /// Given the `src` of a collapsing reshape op and its reassociation maps,
 /// compute the shape of the result of the reshape.
 static SmallVector<OpFoldResult, 4> getCollapsedOutputShapeFromInputShape(
     OpBuilder &builder, Location loc, Value src,
     ArrayRef<int64_t> dstStaticShape, ArrayRef<AffineMap> reassociation) {
   return llvm::to_vector<4>(llvm::map_range(
for (auto d :
     if (d.index() + startPos == static_cast<unsigned>(dimIndex))
       continue;
     assert(!ShapedType::isDynamic(d.value()) &&
            "single dimension cannot be expanded into multiple dynamic "
            "dimensions");
     linearizedStaticDim *= d.value();
   }
   Value sourceDim = builder.create<tensor::DimOp>(loc, src, sourceDimPos);
-  return applyMapToValues(
+  return affine::applyMapToValues(
       builder, loc,
       AffineMap::get(
           0, 1, builder.getAffineSymbolExpr(0).floorDiv(linearizedStaticDim)),
       sourceDim)[0];
 }
 
 /// Given the `src` of an expanding reshape op, the reassociation maps and the
 /// result type, compute the shape of the result of the reshape.
for (auto dim : llvm::seq<int64_t>(0, padOp.getSourceType().getRank())) {
           return;
         }
         int64_t staticValue =
             valueOrAttr.get<Attribute>().cast<IntegerAttr>().getInt();
         expr = expr + staticValue;
       };
       addOpFoldResult(lowPad[dim]);
       addOpFoldResult(highPad[dim]);
-      shapes.push_back(applyMapToValues(
+      shapes.push_back(affine::applyMapToValues(
           b, loc, AffineMap::get(1, numSymbols, expr), mapOperands)[0]);
     }
     reifiedReturnShapes.emplace_back(std::move(shapes));
     return success();
   }
 };
 
 } // namespace

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

for (int64_t d : grp) {
       }
     }
 
     // result dim size = src dim size / (product(other dims in reassoc group))
     Value srcDimSz =
         rewriter.create<DimOp>(dimOp.getLoc(), expandShapeOp.getSrc(), srcDim);
     AffineExpr expr;
     bindSymbols(dimOp.getContext(), expr);
-    rewriter.replaceOpWithNewOp<AffineApplyOp>(dimOp, expr.floorDiv(product),
-                                               srcDimSz);
+    rewriter.replaceOpWithNewOp<affine::AffineApplyOp>(
+        dimOp, expr.floorDiv(product), srcDimSz);
     return success();
   }
 };
 
 struct FoldDimOfCollapseShape : public OpRewritePattern<DimOp> {
   using OpRewritePattern<DimOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(DimOp dimOp,
LogicalResult matchAndRewrite(DimOp dimOp,
     SmallVector<AffineExpr> syms;
     AffineExpr product;
     for (const auto &it : llvm::enumerate(group)) {
       srcDimSizes.push_back(rewriter.create<DimOp>(
           dimOp.getLoc(), collapseShapeOp.getSrc(), it.value()));
       syms.push_back(rewriter.getAffineSymbolExpr(it.index()));
       product = product ? product * syms.back() : syms.back();
     }
-    rewriter.replaceOpWithNewOp<AffineApplyOp>(dimOp, product, srcDimSizes);
+    rewriter.replaceOpWithNewOp<affine::AffineApplyOp>(dimOp, product,
+                                                       srcDimSizes);
     return success();
   }
 };
 } // namespace
 
 void ExpandShapeOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                 MLIRContext *context) {
   results.add<ComposeReassociativeReshapeOps<ExpandShapeOp>,
SmallVector<OpFoldResult> PackOp::getResultShape(
     ArrayRef<OpFoldResult> innerTileSizes, ArrayRef<int64_t> innerDimsPos,
     ArrayRef<int64_t> outerDimsPerm) {
   SmallVector<OpFoldResult> resultDims = llvm::to_vector(sourceDims);
 
   AffineExpr s0, s1;
   bindSymbols(builder.getContext(), s0, s1);
   AffineExpr ceilDivExpr = s0.ceilDiv(s1);
   for (auto tiledDim : llvm::enumerate(innerDimsPos)) {
-    resultDims[tiledDim.value()] = makeComposedFoldedAffineApply(
+    resultDims[tiledDim.value()] = affine::makeComposedFoldedAffineApply(
         builder, loc, ceilDivExpr,
         {resultDims[tiledDim.value()], innerTileSizes[tiledDim.index()]});
   }
   if (!outerDimsPerm.empty())
     applyPermutationToVector(resultDims, outerDimsPerm);
   resultDims.append(innerTileSizes.begin(), innerTileSizes.end());
 
   SmallVector<int64_t> resultTypeShape =

 
 Value PackOp::createDestinationTensor(OpBuilder &b, Location loc, Value source,
                                       ArrayRef<OpFoldResult> innerTileSizes,
                                       ArrayRef<int64_t> innerDimsPos,
                                       ArrayRef<int64_t> outerDimsPerm) {
   AffineExpr dim0, dim1;
   bindDims(b.getContext(), dim0, dim1);
   auto ceilDiv = [&](OpFoldResult v1, OpFoldResult v2) -> OpFoldResult {
-    return makeComposedFoldedAffineApply(b, loc, dim0.ceilDiv(dim1), {v1, v2});
+    return affine::makeComposedFoldedAffineApply(b, loc, dim0.ceilDiv(dim1),
+                                                 {v1, v2});
   };
 
   SmallVector<OpFoldResult> mixedSizes;
   for (auto [index, value] :
        llvm::enumerate(source.getType().cast<RankedTensorType>().getShape())) {
     if (ShapedType::isDynamic(value))
       mixedSizes.push_back(b.create<DimOp>(loc, source, index).getResult());
     else

 Value UnPackOp::createDestinationTensor(OpBuilder &b, Location loc,
                                         Value source,
                                         ArrayRef<OpFoldResult> innerTileSizes,
                                         ArrayRef<int64_t> innerDimsPos,
                                         ArrayRef<int64_t> outerDimsPerm) {
   AffineExpr sym0, sym1;
   bindSymbols(b.getContext(), sym0, sym1);
   auto dimMul = [&](OpFoldResult v1, OpFoldResult v2) -> OpFoldResult {
-    return makeComposedFoldedAffineApply(b, loc, sym0 * sym1, {v1, v2});
+    return affine::makeComposedFoldedAffineApply(b, loc, sym0 * sym1, {v1, v2});
   };
 
   SmallVector<OpFoldResult> mixedSizes;
   auto srcType = source.getType().cast<RankedTensorType>();
   for (auto i :
        llvm::seq<unsigned>(0, srcType.getRank() - innerTileSizes.size())) {
     if (srcType.isDynamicDim(i))
       mixedSizes.push_back(b.create<DimOp>(loc, source, i).getResult());

mlir/lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp

applyPermToRange(origOffsets, origSizes,
                      invertPermutationVector(packOp.getOuterDimsPerm()));
 
     DenseMap<int64_t, OpFoldResult> dimAndTileMapping =
         packOp.getDimAndTileMapping();
     SmallVector<OpFoldResult> srcDimValues =
         tensor::createDimValues(b, loc, packOp.getSource());
     SmallVector<OpFoldResult> inputIndices, inputSizes;
     for (auto dim : llvm::seq<int64_t>(0, inputRank)) {
-      using AV = AffineValueExpr;
-      AffineBuilder ab(b, loc);
+      using AV = affine::AffineValueExpr;
+      affine::AffineBuilder ab(b, loc);
       AffineExpr dim0, dim1, sym;
       bindDims(b.getContext(), dim0, dim1);
       bindSymbols(b.getContext(), sym);
       if (dimAndTileMapping.count(dim)) {
         // If the data dimension is tiled, the i-th index is the product of
         // offset_i and tile_i, and the i-th size is the product of sizes_i and
         // tile_i.
         auto avOffset = AV(dim0).bind(origOffsets[dim]);
if (!dimAndTileMapping.count(tileDim)) {
     info.sourceOffset = tileOffset;
     info.sourceSize = tileSize;
     info.resultOffset = zeroAttr;
     info.destExpandedSize = tileSize;
     return info;
   }
 
   Location loc = unpackOp.getLoc();
-  using AV = AffineValueExpr;
-  AffineBuilder ab(b, loc);
+  using AV = affine::AffineValueExpr;
+  affine::AffineBuilder ab(b, loc);
   AffineExpr dim0, dim1, sym0;
   bindDims(b.getContext(), dim0, dim1);
   bindSymbols(b.getContext(), sym0);
 
   OpFoldResult innerTileSize = dimAndTileMapping[tileDim];
 
   info.isAlignedToInnerTileSize = false;
   FailureOr<int64_t> cstSize = ValueBoundsConstraintSet::computeConstantBound(
if (info.isAlignedToInnerTileSize) {
     // If the tiling size is 32, there will be 3 tiles. Two of them have
     // size=32; one of them have size=2. The size is represented using
     // affine_min op; we need ceilDiv.
     info.sourceSize =
         ab.ceil(AV(dim0).bind(tileSize), AV(dim1).bind(innerTileSize));
     return info;
   }
 
-  DivModValue firstCoord =
-      getDivMod(b, loc, getValueOrCreateConstantIndexOp(b, loc, tileOffset),
-                getValueOrCreateConstantIndexOp(b, loc, innerTileSize));
+  affine::DivModValue firstCoord = affine::getDivMod(
+      b, loc, getValueOrCreateConstantIndexOp(b, loc, tileOffset),
   OpFoldResult tileExclusiveBound =
       ab.add(AV(dim0).bind(tileOffset), AV(dim1).bind(tileSize));
-  DivModValue lastCoord = getDivMod(
+  affine::DivModValue lastCoord = affine::getDivMod(
       b, loc,
       getValueOrCreateConstantIndexOp(
           b, loc,
           ab.sub(AV(dim0).bind(tileExclusiveBound), AV(dim1).bind(oneAttr))),
       getValueOrCreateConstantIndexOp(b, loc, innerTileSize));
 
   OpFoldResult lengthMinusOne = ab.sub(AV(dim0).bind(lastCoord.quotient),
                                        AV(dim1).bind(firstCoord.quotient));
FailureOr<TilingResult> tensor::bubbleUpPadSlice(OpBuilder &b,
   // Helper variables and functions for various arithmetic operations. These
   // are used extensively for computing new offset/length and padding values.
   Location loc = padOp->getLoc();
   AffineExpr dim0, dim1;
   bindDims(b.getContext(), dim0, dim1);
   // Add two integers.
   auto addMap = AffineMap::get(2, 0, {dim0 + dim1});
   auto add = [&](OpFoldResult v1, OpFoldResult v2) {
-    return makeComposedFoldedAffineApply(b, loc, addMap, {v1, v2});
+    return affine::makeComposedFoldedAffineApply(b, loc, addMap, {v1, v2});
   };
   // Subtract two integers.
   auto subMap = AffineMap::get(2, 0, {dim0 - dim1});
   auto sub = [&](OpFoldResult v1, OpFoldResult v2) {
-    return makeComposedFoldedAffineApply(b, loc, subMap, {v1, v2});
+    return affine::makeComposedFoldedAffineApply(b, loc, subMap, {v1, v2});
   };
   // Take the minimum of two integers.
   auto idMap = AffineMap::getMultiDimIdentityMap(2, b.getContext());
   auto min = [&](OpFoldResult v1, OpFoldResult v2) {
-    return makeComposedFoldedAffineMin(b, loc, idMap, {v1, v2});
+    return affine::makeComposedFoldedAffineMin(b, loc, idMap, {v1, v2});
   };
   // Take the maximum of two integers.
   auto max = [&](OpFoldResult v1, OpFoldResult v2) {
-    return makeComposedFoldedAffineMax(b, loc, idMap, {v1, v2});
+    return affine::makeComposedFoldedAffineMax(b, loc, idMap, {v1, v2});
   };
   // Zero index-typed integer.
   OpFoldResult zero = b.getIndexAttr(0);
 
   // Compute new offsets, lengths, low padding, high padding.
   SmallVector<OpFoldResult> newOffsets, newLengths, newStrides;
   SmallVector<OpFoldResult> newLows, newHighs;
   // Set to true if the original data source is not read at all.

mlir/lib/Dialect/Tensor/Transforms/BufferizableOpInterfaceImpl.cpp

for (int64_t i = 0; i < resultType.getRank(); ++i) {
       if (!resultType.isDynamicDim(i))
         continue;
       Value srcDim = rewriter.create<tensor::DimOp>(loc, padOp.getSource(), i);
       Value lowPad = toValue(mixedLowPad[i]);
       Value highPad = toValue(mixedHighPad[i]);
       AffineExpr s0, s1, s2;
       bindSymbols(op->getContext(), s0, s1, s2);
       AffineExpr sumExpr = s0 + s1 + s2;
-      Value sum = rewriter.create<AffineApplyOp>(
+      Value sum = rewriter.create<affine::AffineApplyOp>(
           loc, sumExpr, ValueRange{srcDim, lowPad, highPad});
       dynamicSizes.push_back(sum);
     }
 
     // Should the buffer be deallocated?
     bool dealloc =
         shouldDeallocateOpResult(padOp.getResult().cast<OpResult>(), options);
     // Allocate a buffer for the padded result.

mlir/lib/Dialect/Tensor/Transforms/ExtractSliceFromReshapeUtils.cpp

 #include "mlir/Dialect/Tensor/Transforms/Transforms.h"
 #include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
 #include "mlir/Dialect/Utils/StaticValueUtils.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 using namespace mlir::tensor;
 
 /// Get the dimension size of a value of RankedTensor type at the
 static OpFoldResult getShapeDimSize(OpBuilder &b, Location loc,
                                     Value rankedTensor, int64_t dimIdx) {
   RankedTensorType tensorType = rankedTensor.getType().cast<RankedTensorType>();
   if (!tensorType.isDynamicDim(dimIdx)) {
     return b.getIndexAttr(tensorType.getDimSize(dimIdx));
static DimAndIndex invertSliceIndexing(OpBuilder &b, Location loc,
                                        const DimAndIndex &dimAndIndex) {
   AffineExpr d0, s0, s1;
   bindDims(b.getContext(), d0);
   bindSymbols(b.getContext(), s0, s1);
   auto [dim, indexValue] = dimAndIndex;
   assert(dim < sliceParams.size() && "slice should be non rank-reducing");
   return std::make_pair(
       dim,
-      makeComposedAffineApply(
+      affine::makeComposedAffineApply(
           b, loc, s0 + d0 * s1,
           {indexValue,
            getValueOrCreateConstantIndexOp(b, loc, sliceParams[dim].offset),
            getValueOrCreateConstantIndexOp(b, loc, sliceParams[dim].stride)}));
 }
 
 /// Transform `dimAndIndex` from the result tensor index space of a
 /// CollapseShapeOp to the source tensor index space.

mlir/lib/Dialect/Tensor/Transforms/FoldTensorSubsetOps.cpp

LogicalResult preconditionResult =
       preconditionsFoldExtractOrInsertWithTransferOp(rewriter, readOp,
                                                      extractSliceOp);
   if (failed(preconditionResult))
     return preconditionResult;
 
   SmallVector<Value> indices(readOp.getIndices().begin(),
                              readOp.getIndices().end());
   SmallVector<Value> sourceIndices;
-  resolveIndicesIntoOpWithOffsetsAndStrides(
+  affine::resolveIndicesIntoOpWithOffsetsAndStrides(
       rewriter, readOp.getLoc(), extractSliceOp.getMixedOffsets(),
       extractSliceOp.getMixedStrides(), extractSliceOp.getDroppedDims(),
       indices, sourceIndices);
 
   rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
       readOp, readOp.getVectorType(), extractSliceOp.getSource(), sourceIndices,
       AffineMapAttr::get(expandDimsToRank(
           readOp.getPermutationMap(), extractSliceOp.getSourceType().getRank(),
LogicalResult preconditionResult =
       preconditionsFoldExtractOrInsertWithTransferOp(rewriter, writeOp,
                                                      insertSliceOp);
   if (failed(preconditionResult))
     return preconditionResult;
 
   SmallVector<Value> indices(writeOp.getIndices().begin(),
                              writeOp.getIndices().end());
   SmallVector<Value> sourceIndices;
-  resolveIndicesIntoOpWithOffsetsAndStrides(
+  affine::resolveIndicesIntoOpWithOffsetsAndStrides(
       rewriter, writeOp.getLoc(), insertSliceOp.getMixedOffsets(),
       insertSliceOp.getMixedStrides(), insertSliceOp.getDroppedDims(), indices,
       sourceIndices);
 
   rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
       insertSliceOp, writeOp.getValue(), insertSliceOp.getDest(), sourceIndices,
       AffineMapAttr::get(expandDimsToRank(writeOp.getPermutationMap(),
                                           insertSliceOp.getDestType().getRank(),
for (int64_t d = 0, e = insertSliceOp.getDestType().getRank(); d < e; ++d) {
       }
     }
 
     // Resolve sizes according to dropped dims.
     SmallVector<OpFoldResult> resolvedSizes;
     // Note: the "insertSlice" case is symmetrical to the extract/subview case:
     // `insertSliceOp` is passed as the "source" and `sourceInsertSliceOp` is
     // passed as the destination to the helper function.
-    resolveSizesIntoOpWithSizes(insertSliceOp.getMixedSizes(),
+    affine::resolveSizesIntoOpWithSizes(insertSliceOp.getMixedSizes(),
                                         sourceInsertSliceOp.getMixedSizes(),
                                         droppedDims, resolvedSizes);
 
     // If we are inside an InParallel region, temporarily set the insertion
     // point outside: only tensor.parallel_insert_slice ops are allowed in
     // there.
     if (std::is_same_v<OpTy, tensor::ParallelInsertSliceOp>) {
       rewriter.setInsertionPoint(
           insertSliceOp->template getParentOfType<scf::InParallelOp>());
     }
 
     // Resolve offsets according to source offsets and strides.
     SmallVector<Value> resolvedOffsets;
     // Note: the "insertSlice" case is symmetrical to the extract/subview case:
     // `insertSliceOp` is passed as the "source" and `sourceInsertSliceOp` is
     // passed as the destination to the helper function.
-    resolveIndicesIntoOpWithOffsetsAndStrides(
+    affine::resolveIndicesIntoOpWithOffsetsAndStrides(
         rewriter, insertSliceOp.getLoc(), insertSliceOp.getMixedOffsets(),
         insertSliceOp.getMixedStrides(), droppedDims,
         sourceInsertSliceOp.getMixedOffsets(), resolvedOffsets);
 
     // Reset the insertion point.
     rewriter.setInsertionPoint(insertSliceOp);
     // Replace original op.
     rewriter.replaceOpWithNewOp<OpTy>(

mlir/lib/Dialect/Tensor/Transforms/MergeConsecutiveInsertExtractSlicePatterns.cpp

struct MergeConsecutiveExtractSlice : public OpRewritePattern<ExtractSliceOp> {
 
   LogicalResult matchAndRewrite(ExtractSliceOp nextOp,
                                 PatternRewriter &rewriter) const override {
     auto prevOp = nextOp.getSource().getDefiningOp<ExtractSliceOp>();
     if (!prevOp)
       return failure();
 
     SmallVector<OpFoldResult> newOffsets, newSizes, newStrides;
-    if (failed(mergeOffsetsSizesAndStrides(rewriter, nextOp.getLoc(), prevOp,
-                                           nextOp, prevOp.getDroppedDims(),
-                                           newOffsets, newSizes, newStrides)))
+    if (failed(affine::mergeOffsetsSizesAndStrides(
+            rewriter, nextOp.getLoc(), prevOp, nextOp, prevOp.getDroppedDims(),
       return failure();
 
     rewriter.replaceOpWithNewOp<ExtractSliceOp>(nextOp, nextOp.getType(),
                                                 prevOp.getSource(), newOffsets,
                                                 newSizes, newStrides);
     return success();
   }
 };

mlir/lib/Dialect/Tensor/Utils/Utils.cpp

for (const auto &en : enumerate(type.getShape())) {
     // Pad only the static dimensions of the result tensor type.
     if (ShapedType::isDynamic(en.value()))
       continue;
     // Compute the padding width.
     AffineExpr d0;
     bindDims(b.getContext(), d0);
     auto dimOp = b.createOrFold<tensor::DimOp>(loc, source, en.index());
     high[en.index()] =
-        makeComposedAffineApply(b, loc, en.value() - d0, {dimOp}).getResult();
+        affine::makeComposedAffineApply(b, loc, en.value() - d0, {dimOp})
+            .getResult();
   }
   return b.create<PadOp>(loc, type, source, low, high, pad, nofold);
 }
 
 SmallVector<Value> mlir::tensor::createDynamicDimValues(OpBuilder &b,
                                                         Location loc,
                                                         Value rankedTensor) {
   auto tensorTy = rankedTensor.getType().cast<RankedTensorType>();

mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp

DistributedLoadStoreHelper(Value sequentialVal, Value distributedVal,
     if (sequentialVectorType && distributedVectorType)
       distributionMap =
           calculateImplicitMap(sequentialVectorType, distributedVectorType);
   }
 
   Value buildDistributedOffset(RewriterBase &b, Location loc, int64_t index) {
     int64_t distributedSize = distributedVectorType.getDimSize(index);
     AffineExpr tid = getAffineSymbolExpr(0, b.getContext());
-    return b.createOrFold<AffineApplyOp>(loc, tid * distributedSize,
+    return b.createOrFold<affine::AffineApplyOp>(loc, tid * distributedSize,
                                                  ArrayRef<Value>{laneId});
   }
 
   /// Create a store during the process of distributing the
   /// `vector.warp_execute_on_thread_0` op.
   /// Vector distribution assumes the following convention regarding the
   /// temporary buffers that are created to transition values. This **must**
   /// be properly specified in the `options.warpAllocationFn`:
   ///   1. scalars of type T transit through a memref<1xT>.
for (auto it : llvm::zip(indexMap.getResults(), map.getResults())) {
       bindDims(newWarpOp.getContext(), d0, d1);
       auto indexExpr = std::get<0>(it).dyn_cast<AffineDimExpr>();
       if (!indexExpr)
         continue;
       unsigned indexPos = indexExpr.getPosition();
       unsigned vectorPos = std::get<1>(it).cast<AffineDimExpr>().getPosition();
       auto scale =
           rewriter.getAffineConstantExpr(targetType.getDimSize(vectorPos));
-      indices[indexPos] =
-          makeComposedAffineApply(rewriter, loc, d0 + scale * d1,
-                                  {indices[indexPos], newWarpOp.getLaneid()});
+      indices[indexPos] = affine::makeComposedAffineApply(
+          rewriter, loc, d0 + scale * d1,
     }
     newWriteOp.getIndicesMutable().assign(indices);
 
     return success();
   }
 
   /// Extract TransferWriteOps of vector<1x> into a separate warp op.
   LogicalResult tryExtractOp(RewriterBase &rewriter,
for (auto it : llvm::zip(indexMap.getResults(), map.getResults())) {
       bindDims(read.getContext(), d0, d1);
       auto indexExpr = std::get<0>(it).dyn_cast<AffineDimExpr>();
       if (!indexExpr)
         continue;
       unsigned indexPos = indexExpr.getPosition();
       unsigned vectorPos = std::get<1>(it).cast<AffineDimExpr>().getPosition();
       int64_t scale =
           distributedVal.getType().cast<VectorType>().getDimSize(vectorPos);
-      indices[indexPos] =
-          makeComposedAffineApply(rewriter, read.getLoc(), d0 + scale * d1,
-                                  {indices[indexPos], warpOp.getLaneid()});
+      indices[indexPos] = affine::makeComposedAffineApply(
+          rewriter, read.getLoc(), d0 + scale * d1,
     }
     Value newRead = rewriter.create<vector::TransferReadOp>(
         read.getLoc(), distributedVal.getType(), read.getSource(), indices,
         read.getPermutationMapAttr(), read.getPadding(), read.getMask(),
         read.getInBoundsAttr());
     rewriter.replaceAllUsesWith(distributedVal, newRead);
     return success();
   }
if (is0dOrVec1Extract) {
       return success();
     }
 
     // 1d extract: Distribute the source vector. One lane extracts and shuffles
     // the value to all other lanes.
     int64_t elementsPerLane = distributedVecType.getShape()[0];
     AffineExpr sym0 = getAffineSymbolExpr(0, rewriter.getContext());
     // tid of extracting thread: pos / elementsPerLane
-    Value broadcastFromTid = rewriter.create<AffineApplyOp>(
+    Value broadcastFromTid = rewriter.create<affine::AffineApplyOp>(
         loc, sym0.ceilDiv(elementsPerLane), extractOp.getPosition());
     // Extract at position: pos % elementsPerLane
     Value pos =
         elementsPerLane == 1
             ? rewriter.create<arith::ConstantIndexOp>(loc, 0).getResult()
             : rewriter
-                  .create<AffineApplyOp>(loc, sym0 % elementsPerLane,
+                  .create<affine::AffineApplyOp>(loc, sym0 % elementsPerLane,
                                                  extractOp.getPosition())
                   .getResult();
     Value extracted =
         rewriter.create<vector::ExtractElementOp>(loc, distributedVec, pos);
 
     // Shuffle the extracted value to all lanes.
     Value shuffled = warpShuffleFromIdxFn(
         loc, rewriter, extracted, broadcastFromTid, newWarpOp.getWarpSize());
     rewriter.replaceAllUsesWith(newWarpOp->getResult(operandNumber), shuffled);
if (vecType == distrType) {
                                   newInsert);
       return success();
     }
 
     // This is a distribution. Only one lane should insert.
     int64_t elementsPerLane = distrType.getShape()[0];
     AffineExpr sym0 = getAffineSymbolExpr(0, rewriter.getContext());
     // tid of extracting thread: pos / elementsPerLane
-    Value insertingLane = rewriter.create<AffineApplyOp>(
+    Value insertingLane = rewriter.create<affine::AffineApplyOp>(
         loc, sym0.ceilDiv(elementsPerLane), newPos);
     // Insert position: pos % elementsPerLane
     Value pos =
         elementsPerLane == 1
             ? rewriter.create<arith::ConstantIndexOp>(loc, 0).getResult()
             : rewriter
-                  .create<AffineApplyOp>(loc, sym0 % elementsPerLane, newPos)
+                  .create<affine::AffineApplyOp>(loc, sym0 % elementsPerLane,
+                                                 newPos)
                   .getResult();
     Value isInsertingLane = rewriter.create<arith::CmpIOp>(
         loc, arith::CmpIPredicate::eq, newWarpOp.getLaneid(), insertingLane);
     Value newResult =
         rewriter
             .create<scf::IfOp>(
                 loc, isInsertingLane,
                 /*thenBuilder=*/

mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp

LogicalResult matchAndRewrite(vector::ExtractElementOp extractOp,
     if (xferOp.hasOutOfBoundsDim() && xferOp.getType().getRank() > 0)
       return failure();
     // Construct scalar load.
     SmallVector<Value> newIndices(xferOp.getIndices().begin(),
                                   xferOp.getIndices().end());
     if (extractOp.getPosition()) {
       AffineExpr sym0, sym1;
       bindSymbols(extractOp.getContext(), sym0, sym1);
-      OpFoldResult ofr = makeComposedFoldedAffineApply(
+      OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
           rewriter, extractOp.getLoc(), sym0 + sym1,
           {newIndices[newIndices.size() - 1], extractOp.getPosition()});
       if (ofr.is<Value>()) {
         newIndices[newIndices.size() - 1] = ofr.get<Value>();
       } else {
         newIndices[newIndices.size() - 1] =
             rewriter.create<arith::ConstantIndexOp>(extractOp.getLoc(),
                                                     *getConstantIntValue(ofr));
if (xferOp.hasOutOfBoundsDim() && xferOp.getType().getRank() > 0)
       return failure();
     // Construct scalar load.
     SmallVector<Value> newIndices(xferOp.getIndices().begin(),
                                   xferOp.getIndices().end());
     for (const auto &it : llvm::enumerate(extractOp.getPosition())) {
       int64_t offset = it.value().cast<IntegerAttr>().getInt();
       int64_t idx =
           newIndices.size() - extractOp.getPosition().size() + it.index();
-      OpFoldResult ofr = makeComposedFoldedAffineApply(
+      OpFoldResult ofr = affine::makeComposedFoldedAffineApply(
           rewriter, extractOp.getLoc(),
           rewriter.getAffineSymbolExpr(0) + offset, {newIndices[idx]});
       if (ofr.is<Value>()) {
         newIndices[idx] = ofr.get<Value>();
       } else {
         newIndices[idx] = rewriter.create<arith::ConstantIndexOp>(
             extractOp.getLoc(), *getConstantIntValue(ofr));
       }

mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp

 #define DEBUG_TYPE "vector-transfer-split"
 
 using namespace mlir;
 using namespace mlir::vector;
 
 static std::optional<int64_t> extractConstantIndex(Value v) {
   if (auto cstOp = v.getDefiningOp<arith::ConstantIndexOp>())
     return cstOp.value();
-  if (auto affineApplyOp = v.getDefiningOp<AffineApplyOp>())
+  if (auto affineApplyOp = v.getDefiningOp<affine::AffineApplyOp>())
     if (affineApplyOp.getAffineMap().isSingleConstant())
       return affineApplyOp.getAffineMap().getSingleConstantResult();
   return std::nullopt;
 }
 
 // Missing foldings of scf.if make it necessary to perform poor man's folding
 // eagerly, especially in the case of unrolling. In the future, this should go
 // away once scf.if folds properly.
xferOp.zipResultAndIndexing([&](int64_t resultIdx, int64_t indicesIdx) {
     // the construction of `inBoundsCond`.
     if (xferOp.isDimInBounds(resultIdx))
       return;
     // Fold or create the check that `index + vector_size` <= `memref_size`.
     Location loc = xferOp.getLoc();
     int64_t vectorSize = xferOp.getVectorType().getDimSize(resultIdx);
     auto d0 = getAffineDimExpr(0, xferOp.getContext());
     auto vs = getAffineConstantExpr(vectorSize, xferOp.getContext());
-    Value sum =
-        makeComposedAffineApply(b, loc, d0 + vs, xferOp.indices()[indicesIdx]);
+    Value sum = affine::makeComposedAffineApply(b, loc, d0 + vs,
+                                                xferOp.indices()[indicesIdx]);
     Value cond = createFoldedSLE(
         b, sum, vector::createOrFoldDimOp(b, loc, xferOp.source(), indicesIdx));
     if (!cond)
       return;
     // Conjunction over all dims for which we are in-bounds.
     if (inBoundsCond)
       inBoundsCond = b.create<arith::AndIOp>(loc, inBoundsCond, cond);
     else
Value dimMemRef = vector::createOrFoldDimOp(b, xferOp.getLoc(),
                                                 xferOp.source(), indicesIdx);
     Value dimAlloc = b.create<memref::DimOp>(loc, alloc, resultIdx);
     Value index = xferOp.indices()[indicesIdx];
     AffineExpr i, j, k;
     bindDims(xferOp.getContext(), i, j, k);
     SmallVector<AffineMap, 4> maps =
         AffineMap::inferFromExprList(MapList{{i - j, k}});
     // affine_min(%dimMemRef - %index, %dimAlloc)
-    Value affineMin = b.create<AffineMinOp>(
+    Value affineMin = b.create<affine::AffineMinOp>(
         loc, index.getType(), maps[0], ValueRange{dimMemRef, index, dimAlloc});
     sizes.push_back(affineMin);
   });
 
   SmallVector<OpFoldResult> srcIndices = llvm::to_vector<4>(llvm::map_range(
       xferOp.indices(), [](Value idx) -> OpFoldResult { return idx; }));
   SmallVector<OpFoldResult> destIndices(memrefRank, b.getIndexAttr(0));
   SmallVector<OpFoldResult> strides(memrefRank, b.getIndexAttr(1));
static Operation *getAutomaticAllocationScope(Operation *op) {
   // Find the closest surrounding allocation scope that is not a known looping
   // construct (putting alloca's in loops doesn't always lower to deallocation
   // until the end of the loop).
   Operation *scope = nullptr;
   for (Operation *parent = op->getParentOp(); parent != nullptr;
        parent = parent->getParentOp()) {
     if (parent->hasTrait<OpTrait::AutomaticAllocationScope>())
       scope = parent;
-    if (!isa<scf::ForOp, AffineForOp>(parent))
+    if (!isa<scf::ForOp, affine::AffineForOp>(parent))
       break;
   }
   assert(scope && "Expected op to be inside automatic allocation scope");
   return scope;
 }
 
 /// Split a vector.transfer operation into an in-bounds (i.e., no out-of-bounds
 /// masking) fastpath and a slowpath.

mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp

static SmallVector<Value> sliceTransferIndices(ArrayRef<int64_t> elementOffsets,
   SmallVector<Value> slicedIndices(indices.begin(), indices.end());
   for (const auto &dim : llvm::enumerate(permutationMap.getResults())) {
     if (isBroadcast(dim.value()))
       continue;
     unsigned pos = dim.value().cast<AffineDimExpr>().getPosition();
     auto expr = getAffineDimExpr(0, builder.getContext()) +
                 getAffineConstantExpr(elementOffsets[dim.index()], ctx);
     auto map = AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0, expr);
-    slicedIndices[pos] = builder.create<AffineApplyOp>(loc, map, indices[pos]);
+    slicedIndices[pos] =
+        builder.create<affine::AffineApplyOp>(loc, map, indices[pos]);
   }
   return slicedIndices;
 }
 
 // Clones `op` into a new operations that takes `operands` and returns
 // `resultTypes`.
 static Operation *cloneOpWithOperandsAndTypes(OpBuilder &builder, Location loc,
                                               Operation *op,

mlir/lib/Dialect/Vector/Utils/VectorUtils.cpp

if (enclosingLoopToVectorDim.empty())
     return AffineMap();
   MLIRContext *context =
       enclosingLoopToVectorDim.begin()->getFirst()->getContext();
   SmallVector<AffineExpr> perm(enclosingLoopToVectorDim.size(),
                                getAffineConstantExpr(0, context));
 
   for (auto kvp : enclosingLoopToVectorDim) {
     assert(kvp.second < perm.size());
-    auto invariants = getInvariantAccesses(
-        cast<AffineForOp>(kvp.first).getInductionVar(), indices);
+    auto invariants = affine::getInvariantAccesses(
+        cast<affine::AffineForOp>(kvp.first).getInductionVar(), indices);
     unsigned numIndices = indices.size();
     unsigned countInvariantIndices = 0;
     for (unsigned dim = 0; dim < numIndices; ++dim) {
       if (!invariants.count(indices[dim])) {
         assert(perm[kvp.second] == getAffineConstantExpr(0, context) &&
                "permutationMap already has an entry along dim");
         perm[kvp.second] = getAffineDimExpr(dim, context);
       } else {
while (current) {
     }
     current = current->getParentOp();
   }
   return res;
 }
 
 /// Returns the enclosing AffineForOp, from closest to farthest.
 static SetVector<Operation *> getEnclosingforOps(Block *block) {
-  return getParentsOfType<AffineForOp>(block);
+  return getParentsOfType<affine::AffineForOp>(block);
 }
 
 AffineMap mlir::makePermutationMap(
     Block *insertPoint, ArrayRef<Value> indices,
     const DenseMap<Operation *, unsigned> &loopToVectorDim) {
   DenseMap<Operation *, unsigned> enclosingLoopToVectorDim;
   auto enclosingLoops = getEnclosingforOps(insertPoint);
   for (auto *forInst : enclosingLoops) {

mlir/test/lib/Analysis/TestMemRefBoundCheck.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "memref-bound-check"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// Checks for out of bound memref access subscripts..
 struct TestMemRefBoundCheck
     : public PassWrapper<TestMemRefBoundCheck, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMemRefBoundCheck)
 

mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp

 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "test-memref-dependence-check"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 // TODO: Add common surrounding loop depth-wise dependence checks.
 /// Checks dependences between all pairs of memref accesses in a Function.
 struct TestMemRefDependenceCheck
     : public PassWrapper<TestMemRefDependenceCheck, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMemRefDependenceCheck)

mlir/test/lib/Dialect/Affine/TestAffineDataCopy.cpp

 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 
 #define PASS_NAME "test-affine-data-copy"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 struct TestAffineDataCopy
     : public PassWrapper<TestAffineDataCopy, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAffineDataCopy)
 
   StringRef getArgument() const final { return PASS_NAME; }

mlir/test/lib/Dialect/Affine/TestAffineLoopParametricTiling.cpp

 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 #define DEBUG_TYPE "test-affine-parametric-tile"
 
 namespace {
 struct TestAffineLoopParametricTiling
     : public PassWrapper<TestAffineLoopParametricTiling,
                          OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAffineLoopParametricTiling)

mlir/test/lib/Dialect/Affine/TestAffineLoopUnswitching.cpp

 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/Utils.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 #define PASS_NAME "test-affine-loop-unswitch"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestAffineLoopUnswitching
     : public PassWrapper<TestAffineLoopUnswitching, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestAffineLoopUnswitching)
 

mlir/test/lib/Dialect/Affine/TestDecomposeAffineOps.cpp

 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 #define PASS_NAME "test-decompose-affine-ops"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 struct TestDecomposeAffineOps
     : public PassWrapper<TestDecomposeAffineOps, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDecomposeAffineOps)
 
   StringRef getArgument() const final { return PASS_NAME; }

mlir/test/lib/Dialect/Affine/TestLoopFusion.cpp

 #include "mlir/Dialect/Affine/LoopFusionUtils.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Pass/Pass.h"
 
 #define DEBUG_TYPE "test-loop-fusion"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
 
 static llvm::cl::opt<bool> clTestDependenceCheck(
     "test-loop-fusion-dependence-check",
     llvm::cl::desc("Enable testing of loop fusion dependence check"),
     llvm::cl::cat(clOptionsCategory));
 

 
 // Run fusion dependence check on 'loops[i]' and 'loops[j]' at loop depths
 // in range ['loopDepth' + 1, 'maxLoopDepth'].
 // Emits a remark on 'loops[i]' if a fusion-preventing dependence exists.
 // Returns false as IR is not transformed.
 static bool testDependenceCheck(AffineForOp srcForOp, AffineForOp dstForOp,
                                 unsigned i, unsigned j, unsigned loopDepth,
                                 unsigned maxLoopDepth) {
-  mlir::ComputationSliceState sliceUnion;
+  affine::ComputationSliceState sliceUnion;
   for (unsigned d = loopDepth + 1; d <= maxLoopDepth; ++d) {
     FusionResult result =
-        mlir::canFuseLoops(srcForOp, dstForOp, d, &sliceUnion);
+        affine::canFuseLoops(srcForOp, dstForOp, d, &sliceUnion);
     if (result.value == FusionResult::FailBlockDependence) {
       srcForOp->emitRemark("block-level dependence preventing"
                            " fusion of loop nest ")
           << i << " into loop nest " << j << " at depth " << loopDepth;
     }
   }
   return false;
 }
 
 // Returns the index of 'op' in its block.
 static unsigned getBlockIndex(Operation &op) {
   unsigned index = 0;
   for (auto &opX : *op.getBlock()) {
     if (&op == &opX)
       break;
     ++index;
   }
   return index;
 }
 
 // Returns a string representation of 'sliceUnion'.
-static std::string getSliceStr(const mlir::ComputationSliceState &sliceUnion) {
+static std::string
+getSliceStr(const affine::ComputationSliceState &sliceUnion) {
   std::string result;
   llvm::raw_string_ostream os(result);
   // Slice insertion point format [loop-depth, operation-block-index]
   unsigned ipd = getNestingDepth(&*sliceUnion.insertPoint);
   unsigned ipb = getBlockIndex(*sliceUnion.insertPoint);
   os << "insert point: (" << std::to_string(ipd) << ", " << std::to_string(ipb)
      << ")";
   assert(sliceUnion.lbs.size() == sliceUnion.ubs.size());

 /// in range ['loopDepth' + 1, 'maxLoopDepth'].
 /// Emits a string representation of the slice union as a remark on 'loops[j]'
 /// and marks this as incorrect slice if the slice is invalid. Returns false as
 /// IR is not transformed.
 static bool testSliceComputation(AffineForOp forOpA, AffineForOp forOpB,
                                  unsigned i, unsigned j, unsigned loopDepth,
                                  unsigned maxLoopDepth) {
   for (unsigned d = loopDepth + 1; d <= maxLoopDepth; ++d) {
-    mlir::ComputationSliceState sliceUnion;
-    FusionResult result = mlir::canFuseLoops(forOpA, forOpB, d, &sliceUnion);
+    affine::ComputationSliceState sliceUnion;
+    FusionResult result = affine::canFuseLoops(forOpA, forOpB, d, &sliceUnion);
     if (result.value == FusionResult::Success) {
       forOpB->emitRemark("slice (")
           << " src loop: " << i << ", dst loop: " << j << ", depth: " << d
           << " : " << getSliceStr(sliceUnion) << ")";
     } else if (result.value == FusionResult::FailIncorrectSlice) {
       forOpB->emitRemark("Incorrect slice (")
           << " src loop: " << i << ", dst loop: " << j << ", depth: " << d
           << " : " << getSliceStr(sliceUnion) << ")";
     }
   }
   return false;
 }
 
 // Attempts to fuse 'forOpA' into 'forOpB' at loop depths in range
 // ['loopDepth' + 1, 'maxLoopDepth'].
 // Returns true if loops were successfully fused, false otherwise.
 static bool testLoopFusionTransformation(AffineForOp forOpA, AffineForOp forOpB,
                                          unsigned i, unsigned j,
                                          unsigned loopDepth,
                                          unsigned maxLoopDepth) {
   for (unsigned d = loopDepth + 1; d <= maxLoopDepth; ++d) {
-    mlir::ComputationSliceState sliceUnion;
-    FusionResult result = mlir::canFuseLoops(forOpA, forOpB, d, &sliceUnion);
+    affine::ComputationSliceState sliceUnion;
+    FusionResult result = affine::canFuseLoops(forOpA, forOpB, d, &sliceUnion);
     if (result.value == FusionResult::Success) {
-      mlir::fuseLoops(forOpA, forOpB, sliceUnion);
+      affine::fuseLoops(forOpA, forOpB, sliceUnion);
       // Note: 'forOpA' is removed to simplify test output. A proper loop
       // fusion pass should check the data dependence graph and run memref
       // region analysis to ensure removing 'forOpA' is safe.
       forOpA.erase();
       return true;
     }
   }
   return false;

mlir/test/lib/Dialect/Affine/TestLoopMapping.cpp

 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 struct TestLoopMappingPass
     : public PassWrapper<TestLoopMappingPass, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLoopMappingPass)
 
   StringRef getArgument() const final {
     return "test-mapping-to-processing-elements";
   }
   StringRef getDescription() const final {
     return "test mapping a single loop on a virtual processor grid";
   }
   explicit TestLoopMappingPass() = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, scf::SCFDialect>();
+    registry.insert<affine::AffineDialect, scf::SCFDialect>();
   }
 
   void runOnOperation() override {
     // SSA values for the transformation are created out of thin air by
     // unregistered "new_processor_id_and_range" operations. This is enough to
     // emulate mapping conditions.
     SmallVector<Value, 8> processorIds, numProcessors;
     getOperation()->walk([&processorIds, &numProcessors](Operation *op) {

mlir/test/lib/Dialect/Affine/TestLoopPermutation.cpp

 #include "mlir/Dialect/Affine/Analysis/Utils.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Affine/LoopUtils.h"
 #include "mlir/Pass/Pass.h"
 
 #define PASS_NAME "test-loop-permutation"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestLoopPermutation
     : public PassWrapper<TestLoopPermutation, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLoopPermutation)
 

mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp

 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Interfaces/ValueBoundsOpInterface.h"
 #include "mlir/Pass/Pass.h"
 
 #define PASS_NAME "test-affine-reify-value-bounds"
 
 using namespace mlir;
+using namespace mlir::affine;
 using mlir::presburger::BoundType;
 
 namespace {
 
 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestReifyValueBounds
     : public PassWrapper<TestReifyValueBounds, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestReifyValueBounds)
 
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests ValueBoundsOpInterface with affine dialect reification";
   }
   TestReifyValueBounds() = default;
   TestReifyValueBounds(const TestReifyValueBounds &pass) : PassWrapper(pass){};
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry
-        .insert<AffineDialect, tensor::TensorDialect, memref::MemRefDialect>();
+    registry.insert<affine::AffineDialect, tensor::TensorDialect,
+                    memref::MemRefDialect>();
   }
 
   void runOnOperation() override;
 
 private:
   Option<bool> reifyToFuncArgs{
       *this, "reify-to-func-args",
       llvm::cl::desc("Reify in terms of function args"), llvm::cl::init(false)};

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "affine-super-vectorizer-test"
 
 using namespace mlir;
+using namespace mlir::affine;
 
 static llvm::cl::OptionCategory clOptionsCategory(DEBUG_TYPE " options");
 
 static llvm::cl::list<int> clTestVectorShapeRatio(
     "vector-shape-ratio",
     llvm::cl::desc("Specify the HW vector size for vectorization"),
     llvm::cl::cat(clOptionsCategory));
 static llvm::cl::opt<bool> clTestForwardSlicingAnalysis(
struct VectorizerTestPass
   /// Test for 'vectorizeAffineLoopNest' utility.
   void testVecAffineLoopNest(llvm::raw_ostream &outs);
 };
 
 } // namespace
 
 void VectorizerTestPass::testVectorShapeRatio(llvm::raw_ostream &outs) {
   auto f = getOperation();
-  using matcher::Op;
+  using affine::matcher::Op;
   SmallVector<int64_t, 8> shape(clTestVectorShapeRatio.begin(),
                                 clTestVectorShapeRatio.end());
   auto subVectorType =
       VectorType::get(shape, FloatType::getF32(f.getContext()));
   // Only filter operations that operate on a strict super-vector and have one
   // return. This makes testing easier.
   auto filter = [&](Operation &op) {
     assert(subVectorType.getElementType().isF32() &&
            "Only f32 supported for now");
-    if (!matcher::operatesOnSuperVectorsOf(op, subVectorType)) {
+    if (!mlir::matcher::operatesOnSuperVectorsOf(op, subVectorType)) {
       return false;
     }
     if (op.getNumResults() != 1) {
       return false;
     }
     return true;
   };
   auto pat = Op(filter);
for (auto m : matches) {
     } else {
       outs << "\nmatched: " << *opInst << " with shape ratio: ";
       llvm::interleaveComma(MutableArrayRef<int64_t>(*ratio), outs);
     }
   }
 }
 
 static NestedPattern patternTestSlicingOps() {
-  using matcher::Op;
+  using affine::matcher::Op;
   // Match all operations with the kTestSlicingOpName name.
   auto filter = [](Operation &op) {
     // Just use a custom op name for this test, it makes life easier.
     return op.getName().getStringRef() == "slicing-test-op";
   };
   return Op(filter);
 }
 

 static bool customOpWithAffineMapAttribute(Operation &op) {
   return op.getName().getStringRef() ==
          VectorizerTestPass::kTestAffineMapOpName;
 }
 
 void VectorizerTestPass::testComposeMaps(llvm::raw_ostream &outs) {
   auto f = getOperation();
 
-  using matcher::Op;
+  using affine::matcher::Op;
   auto pattern = Op(customOpWithAffineMapAttribute);
   SmallVector<NestedMatch, 8> matches;
   pattern.match(f, &matches);
   SmallVector<AffineMap, 4> maps;
   maps.reserve(matches.size());
   for (auto m : llvm::reverse(matches)) {
     auto *opInst = m.getMatchedOperation();
     auto map = opInst->getAttr(VectorizerTestPass::kTestAffineMapAttrName)

mlir/test/lib/Dialect/GPU/TestGpuMemoryPromotion.cpp

 /// does not check whether the promotion is legal (e.g., amount of memory used)
 /// or beneficial (e.g., makes previously uncoalesced loads coalesced).
 struct TestGpuMemoryPromotionPass
     : public PassWrapper<TestGpuMemoryPromotionPass,
                          OperationPass<gpu::GPUFuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestGpuMemoryPromotionPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, memref::MemRefDialect, scf::SCFDialect>();
+    registry.insert<affine::AffineDialect, memref::MemRefDialect,
+                    scf::SCFDialect>();
   }
   StringRef getArgument() const final { return "test-gpu-memory-promotion"; }
   StringRef getDescription() const final {
     return "Promotes the annotated arguments of gpu.func to workgroup memory.";
   }
 
   void runOnOperation() override {
     gpu::GPUFuncOp op = getOperation();

mlir/test/lib/Dialect/Linalg/TestDataLayoutPropagation.cpp

 using namespace mlir;
 
 namespace {
 struct TestDataLayoutPropagationPass
     : public PassWrapper<TestDataLayoutPropagationPass, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDataLayoutPropagationPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry
-        .insert<AffineDialect, linalg::LinalgDialect, tensor::TensorDialect>();
+    registry.insert<affine::AffineDialect, linalg::LinalgDialect,
+                    tensor::TensorDialect>();
   }
 
   StringRef getArgument() const final {
     return "test-linalg-data-layout-propagation";
   }
   StringRef getDescription() const final {
     return "Test data layout propagation";
   }

mlir/test/lib/Dialect/Linalg/TestLinalgDecomposeOps.cpp

 struct TestLinalgDecomposeOps
     : public PassWrapper<TestLinalgDecomposeOps, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgDecomposeOps)
 
   TestLinalgDecomposeOps() = default;
   TestLinalgDecomposeOps(const TestLinalgDecomposeOps &pass)
       : PassWrapper(pass){};
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, linalg::LinalgDialect>();
+    registry.insert<affine::AffineDialect, linalg::LinalgDialect>();
   }
   StringRef getArgument() const final { return "test-linalg-decompose-ops"; }
   StringRef getDescription() const final {
     return "Test Linalg decomposition patterns";
   }
 
   Option<bool> removeDeadArgsAndResults{
       *this, "remove-dead-args-and-results",

mlir/test/lib/Dialect/Linalg/TestLinalgElementwiseFusion.cpp

struct TestLinalgElementwiseFusion
     : public PassWrapper<TestLinalgElementwiseFusion,
                          OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgElementwiseFusion)
 
   TestLinalgElementwiseFusion() = default;
   TestLinalgElementwiseFusion(const TestLinalgElementwiseFusion &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
-                    tensor::TensorDialect>();
+    registry.insert<affine::AffineDialect, linalg::LinalgDialect,
+                    memref::MemRefDialect, tensor::TensorDialect>();
   }
   StringRef getArgument() const final {
     return "test-linalg-elementwise-fusion-patterns";
   }
   StringRef getDescription() const final {
     return "Test Linalg element wise operation fusion patterns";
   }
 

mlir/test/lib/Dialect/Linalg/TestLinalgFusionTransforms.cpp

 }
 
 namespace {
 struct TestLinalgGreedyFusion
     : public PassWrapper<TestLinalgGreedyFusion, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgGreedyFusion)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
-                    scf::SCFDialect>();
+    registry.insert<affine::AffineDialect, linalg::LinalgDialect,
+                    memref::MemRefDialect, scf::SCFDialect>();
   }
   StringRef getArgument() const final { return "test-linalg-greedy-fusion"; }
   StringRef getDescription() const final {
     return "Test Linalg fusion by applying a greedy test transformation.";
   }
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns =

mlir/test/lib/Dialect/Linalg/TestLinalgTransforms.cpp

struct TestLinalgTransforms
     : public PassWrapper<TestLinalgTransforms, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLinalgTransforms)
 
   TestLinalgTransforms() = default;
   TestLinalgTransforms(const TestLinalgTransforms &pass) : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
-    registry.insert<AffineDialect,
+    registry.insert<affine::AffineDialect,
                     bufferization::BufferizationDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,
                     linalg::LinalgDialect,
                     vector::VectorDialect,
                     gpu::GPUDialect>();
     // clang-format on
   }

mlir/test/lib/Dialect/Linalg/TestPadFusion.cpp

 using namespace mlir;
 
 namespace {
 struct TestPadFusionPass
     : public PassWrapper<TestPadFusionPass, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestPadFusionPass)
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry
-        .insert<AffineDialect, linalg::LinalgDialect, tensor::TensorDialect>();
+    registry.insert<affine::AffineDialect, linalg::LinalgDialect,
+                    tensor::TensorDialect>();
   }
 
   StringRef getArgument() const final { return "test-linalg-pad-fusion"; }
   StringRef getDescription() const final { return "Test PadOp fusion"; }
 
   void runOnOperation() override {
     MLIRContext *context = &getContext();
     RewritePatternSet patterns(context);

mlir/test/lib/Dialect/MemRef/TestComposeSubView.cpp

StringRef getDescription() const final {
     return "Test combining composed subviews";
   }
   void runOnOperation() override;
   void getDependentDialects(DialectRegistry &registry) const override;
 };
 
 void TestComposeSubViewPass::getDependentDialects(
     DialectRegistry &registry) const {
-  registry.insert<AffineDialect>();
+  registry.insert<affine::AffineDialect>();
 }
 
 void TestComposeSubViewPass::runOnOperation() {
   RewritePatternSet patterns(&getContext());
   memref::populateComposeSubViewPatterns(patterns, &getContext());
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 } // namespace
 
 namespace mlir {
 namespace test {
 void registerTestComposeSubView() {
   PassRegistration<TestComposeSubViewPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/MemRef/TestMultiBuffer.cpp

 struct TestMultiBufferingPass
     : public PassWrapper<TestMultiBufferingPass, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestMultiBufferingPass)
 
   TestMultiBufferingPass() = default;
   TestMultiBufferingPass(const TestMultiBufferingPass &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect>();
+    registry.insert<affine::AffineDialect>();
   }
   StringRef getArgument() const final { return "test-multi-buffering"; }
   StringRef getDescription() const final {
     return "Test multi buffering transformation";
   }
   void runOnOperation() override;
   Option<unsigned> multiplier{
       *this, "multiplier",

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

struct TestVectorToVectorLowering
   StringRef getArgument() const final {
     return "test-vector-to-vector-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns between ops in the vector dialect";
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect>();
+    registry.insert<affine::AffineDialect>();
   }
 
   Option<bool> unroll{*this, "unroll", llvm::cl::desc("Include unrolling"),
                       llvm::cl::init(false)};
 
   void runOnOperation() override {
     auto *ctx = &getContext();
     RewritePatternSet patterns(ctx);
StringRef getArgument() const final {
     return "test-vector-contraction-prepare-for-mmt-lowering";
   }
   StringRef getDescription() const final {
     return "Test vector.contraction matmul canonicalization for MMT lowering.";
   }
   TestVectorContractionPrepareForMMTLowering() = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry
-        .insert<AffineDialect, arith::ArithDialect, vector::VectorDialect>();
+    registry.insert<affine::AffineDialect, arith::ArithDialect,
+                    vector::VectorDialect>();
   }
 
   void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     vector::populateVectorContractCanonicalizeMatmulToMMT(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
       TestVectorTransferUnrollingPatterns)
 
   TestVectorTransferUnrollingPatterns() = default;
   TestVectorTransferUnrollingPatterns(
       const TestVectorTransferUnrollingPatterns &pass)
       : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect>();
+    registry.insert<affine::AffineDialect>();
   }
   StringRef getArgument() const final {
     return "test-vector-transfer-unrolling-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to unroll transfer ops in the vector "
            "dialect";
   }
StringRef getArgument() const final {
     return "test-scalar-vector-transfer-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering of scalar vector transfers to memref loads/stores.";
   }
   TestScalarVectorTransferLoweringPatterns() = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, memref::MemRefDialect, tensor::TensorDialect,
-                    vector::VectorDialect>();
+    registry.insert<affine::AffineDialect, memref::MemRefDialect,
+                    tensor::TensorDialect, vector::VectorDialect>();
   }
 
   void runOnOperation() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     vector::populateScalarVectorTransferLoweringPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
   }
struct TestVectorTransferCollapseInnerMostContiguousDims
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(
       TestVectorTransferCollapseInnerMostContiguousDims)
 
   TestVectorTransferCollapseInnerMostContiguousDims() = default;
   TestVectorTransferCollapseInnerMostContiguousDims(
       const TestVectorTransferCollapseInnerMostContiguousDims &pass) = default;
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<memref::MemRefDialect, AffineDialect>();
+    registry.insert<memref::MemRefDialect, affine::AffineDialect>();
   }
 
   StringRef getArgument() const final {
     return "test-vector-transfer-collapse-inner-most-dims";
   }
 
   StringRef getDescription() const final {
     return "Test lowering patterns that reducedes the rank of the vector "

 }
 
 struct TestVectorDistribution
     : public PassWrapper<TestVectorDistribution, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestVectorDistribution)
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<scf::SCFDialect, memref::MemRefDialect, gpu::GPUDialect,
-                    AffineDialect>();
+                    affine::AffineDialect>();
   }
 
   StringRef getArgument() const final { return "test-vector-warp-distribute"; }
   StringRef getDescription() const final {
     return "Test vector warp distribute transformation and lowering patterns";
   }
   TestVectorDistribution() = default;
   TestVectorDistribution(const TestVectorDistribution &pass)

mlir/test/lib/Interfaces/TilingInterface/TestTilingInterface.cpp

 struct TestTilingInterfacePass
     : public PassWrapper<TestTilingInterfacePass, OperationPass<func::FuncOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestTilingInterfacePass)
 
   TestTilingInterfacePass() = default;
   TestTilingInterfacePass(const TestTilingInterfacePass &pass)
       : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
-                    scf::SCFDialect, tensor::TensorDialect>();
+    registry.insert<affine::AffineDialect, linalg::LinalgDialect,
+                    memref::MemRefDialect, scf::SCFDialect,
+                    tensor::TensorDialect>();
     linalg::registerTilingInterfaceExternalModels(registry);
     tensor::registerTilingInterfaceExternalModels(registry);
   }
   StringRef getArgument() const final { return "test-tiling-interface"; }
   StringRef getDescription() const final {
     return "Test tiling using TilingInterface";
   }
 

mlir/unittests/Analysis/Presburger/Parser.h

 
 namespace mlir {
 namespace presburger {
 
 /// Parses an IntegerPolyhedron from a StringRef. It is expected that the string
 /// represents a valid IntegerSet.
 inline IntegerPolyhedron parseIntegerPolyhedron(StringRef str) {
   MLIRContext context(MLIRContext::Threading::DISABLED);
-  return FlatAffineValueConstraints(parseIntegerSet(str, &context));
+  return affine::FlatAffineValueConstraints(parseIntegerSet(str, &context));
 }
 
 /// Parse a list of StringRefs to IntegerRelation and combine them into a
 /// PresburgerSet by using the union operation. It is expected that the strings
 /// are all valid IntegerSet representation and that all of them have compatible
 /// spaces.
 inline PresburgerSet parsePresburgerSet(ArrayRef<StringRef> strs) {
   assert(!strs.empty() && "strs should not be empty");