Adjust "end namespace" comment in MLIR to match new agree'd coding style

[mehdi_amini]

Summary

See D115115 and this mailing list discussion:
https://lists.llvm.org/pipermail/llvm-dev/2021-December/154199.html

[rriddle]

LGTM, though a few have trailing periods that we should also drop

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

269

Can we trim the trailing period on all of these?

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

2037

same here

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

194

same

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

317

same here and a few others

[mehdi_amini]

LGTM, though a few have trailing periods that we should also drop

Fixed these before pushing

mlir/docs/PassManagement.md

void runOnOperation() override {
     FuncOp f = getOperation();
 
     // Walk the operations within the function.
     f.walk([](Operation *inst) {
       ....
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 /// Register this pass so that it can be built via from a textual pass pipeline.
 /// (Pass registration is discussed more below)
 void registerMyPass() {
   PassRegistration<MyFunctionPass>();
 }
 ```
 

mlir/examples/toy/Ch3/mlir/ToyCombine.cpp

 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"
-} // end anonymous namespace
+} // namespace
 
 /// This is an example of a c++ rewrite pattern for the TransposeOp. It
 /// optimizes the following scenario: transpose(transpose(x)) -> x
 struct SimplifyRedundantTranspose : public mlir::OpRewritePattern<TransposeOp> {
   /// We register this pattern to match every toy.transpose in the IR.
   /// The "benefit" is used by the framework to order the patterns and process
   /// them in order of profitability.
   SimplifyRedundantTranspose(mlir::MLIRContext *context)

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

 
 #include <memory>
 
 namespace mlir {
 class Pass;
 
 namespace toy {
 std::unique_ptr<Pass> createShapeInferencePass();
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

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

 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace toy {
 
 /// Include the auto-generated declarations.
 #include "toy/ShapeInferenceOpInterfaces.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_SHAPEINFERENCEINTERFACE_H_

mlir/examples/toy/Ch4/mlir/ShapeInferencePass.cpp

public:
   /// A utility method that returns if the given operation has a dynamically
   /// shaped result.
   static bool returnsDynamicShape(Operation *op) {
     return llvm::any_of(op->getResultTypes(), [](Type resultType) {
       return !resultType.isa<RankedTensorType>();
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 /// Create a Shape Inference pass.
 std::unique_ptr<mlir::Pass> mlir::toy::createShapeInferencePass() {
   return std::make_unique<ShapeInferencePass>();
 }

mlir/examples/toy/Ch4/mlir/ToyCombine.cpp

 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"
-} // end anonymous namespace
+} // namespace
 
 /// This is an example of a c++ rewrite pattern for the TransposeOp. It
 /// optimizes the following scenario: transpose(transpose(x)) -> x
 struct SimplifyRedundantTranspose : public mlir::OpRewritePattern<TransposeOp> {
   /// We register this pattern to match every toy.transpose in the IR.
   /// The "benefit" is used by the framework to order the patterns and process
   /// them in order of profitability.
   SimplifyRedundantTranspose(mlir::MLIRContext *context)

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

 
 namespace toy {
 std::unique_ptr<Pass> createShapeInferencePass();
 
 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

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

 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace toy {
 
 /// Include the auto-generated declarations.
 #include "toy/ShapeInferenceOpInterfaces.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_SHAPEINFERENCEINTERFACE_H_

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

lowerOpToLoops(op, operands, rewriter,
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });
     return success();
   }
 };
 
-} // end anonymous namespace.
+} // 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, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect>();
   }
   void runOnFunction() final;
 };
-} // end anonymous namespace.
+} // namespace
 
 void ToyToAffineLoweringPass::runOnFunction() {
   auto function = getFunction();
 
   // We only lower the main function as we expect that all other functions have
   // been inlined.
   if (function.getName() != "main")
     return;

mlir/examples/toy/Ch5/mlir/ShapeInferencePass.cpp

public:
   /// A utility method that returns if the given operation has a dynamically
   /// shaped result.
   static bool returnsDynamicShape(Operation *op) {
     return llvm::any_of(op->getResultTypes(), [](Type resultType) {
       return !resultType.isa<RankedTensorType>();
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 /// Create a Shape Inference pass.
 std::unique_ptr<mlir::Pass> mlir::toy::createShapeInferencePass() {
   return std::make_unique<ShapeInferencePass>();
 }

mlir/examples/toy/Ch5/mlir/ToyCombine.cpp

 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"
-} // end anonymous namespace
+} // namespace
 
 /// This is an example of a c++ rewrite pattern for the TransposeOp. It
 /// optimizes the following scenario: transpose(transpose(x)) -> x
 struct SimplifyRedundantTranspose : public mlir::OpRewritePattern<TransposeOp> {
   /// We register this pattern to match every toy.transpose in the IR.
   /// The "benefit" is used by the framework to order the patterns and process
   /// them in order of profitability.
   SimplifyRedundantTranspose(mlir::MLIRContext *context)

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

 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 /// Create a pass for lowering operations the remaining `Toy` operations, as
 /// well as `Affine` and `Std`, to the LLVM dialect for codegen.
 std::unique_ptr<mlir::Pass> createLowerToLLVMPass();
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

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

 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace toy {
 
 /// Include the auto-generated declarations.
 #include "toy/ShapeInferenceOpInterfaces.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_SHAPEINFERENCEINTERFACE_H_

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

lowerOpToLoops(op, operands, rewriter,
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });
     return success();
   }
 };
 
-} // end anonymous namespace.
+} // 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, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect>();
   }
   void runOnFunction() final;
 };
-} // end anonymous namespace.
+} // namespace
 
 void ToyToAffineLoweringPass::runOnFunction() {
   auto function = getFunction();
 
   // We only lower the main function as we expect that all other functions have
   // been inlined.
   if (function.getName() != "main")
     return;

mlir/examples/toy/Ch6/mlir/LowerToLLVM.cpp

Value cst0 = builder.create<LLVM::ConstantOp>(
         loc, IntegerType::get(builder.getContext(), 64),
         builder.getIntegerAttr(builder.getIndexType(), 0));
     return builder.create<LLVM::GEPOp>(
         loc,
         LLVM::LLVMPointerType::get(IntegerType::get(builder.getContext(), 8)),
         globalPtr, ArrayRef<Value>({cst0, cst0}));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ToyToLLVMLoweringPass
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ToyToLLVMLoweringPass
     : public PassWrapper<ToyToLLVMLoweringPass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<LLVM::LLVMDialect, scf::SCFDialect>();
   }
   void runOnOperation() final;
 };
-} // end anonymous namespace
+} // namespace
 
 void ToyToLLVMLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering. For this lowering, we are only targeting
   // the LLVM dialect.
   LLVMConversionTarget target(getContext());
   target.addLegalOp<ModuleOp>();
 

mlir/examples/toy/Ch6/mlir/ShapeInferencePass.cpp

public:
   /// A utility method that returns if the given operation has a dynamically
   /// shaped result.
   static bool returnsDynamicShape(Operation *op) {
     return llvm::any_of(op->getResultTypes(), [](Type resultType) {
       return !resultType.isa<RankedTensorType>();
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 /// Create a Shape Inference pass.
 std::unique_ptr<mlir::Pass> mlir::toy::createShapeInferencePass() {
   return std::make_unique<ShapeInferencePass>();
 }

mlir/examples/toy/Ch6/mlir/ToyCombine.cpp

 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"
-} // end anonymous namespace
+} // namespace
 
 /// This is an example of a c++ rewrite pattern for the TransposeOp. It
 /// optimizes the following scenario: transpose(transpose(x)) -> x
 struct SimplifyRedundantTranspose : public mlir::OpRewritePattern<TransposeOp> {
   /// We register this pattern to match every toy.transpose in the IR.
   /// The "benefit" is used by the framework to order the patterns and process
   /// them in order of profitability.
   SimplifyRedundantTranspose(mlir::MLIRContext *context)

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

 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 namespace detail {
 struct StructTypeStorage;
-} // end namespace detail
-} // end namespace toy
-} // end namespace mlir
+} // namespace detail
+} // namespace toy
+} // namespace mlir
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
public:
   static StructType get(llvm::ArrayRef<mlir::Type> elementTypes);
 
   /// Returns the element types of this struct type.
   llvm::ArrayRef<mlir::Type> getElementTypes();
 
   /// Returns the number of element type held by this struct.
   size_t getNumElementTypes() { return getElementTypes().size(); }
 };
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

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

 /// Create a pass for lowering to operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<mlir::Pass> createLowerToAffinePass();
 
 /// Create a pass for lowering operations the remaining `Toy` operations, as
 /// well as `Affine` and `Std`, to the LLVM dialect for codegen.
 std::unique_ptr<mlir::Pass> createLowerToLLVMPass();
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_PASSES_H

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

 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 namespace toy {
 
 /// Include the auto-generated declarations.
 #include "toy/ShapeInferenceOpInterfaces.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
+} // namespace toy
+} // namespace mlir
 
 #endif // MLIR_TUTORIAL_TOY_SHAPEINFERENCEINTERFACE_H_

mlir/examples/toy/Ch7/mlir/Dialect.cpp

static StructTypeStorage *construct(mlir::TypeStorageAllocator &allocator,
     // Allocate the storage instance and construct it.
     return new (allocator.allocate<StructTypeStorage>())
         StructTypeStorage(elementTypes);
   }
 
   /// The following field contains the element types of the struct.
   llvm::ArrayRef<mlir::Type> elementTypes;
 };
-} // end namespace detail
-} // end namespace toy
-} // end namespace mlir
+} // namespace detail
+} // namespace toy
+} // namespace mlir
 
 /// Create an instance of a `StructType` with the given element types. There
 /// *must* be at least one element type.
 StructType StructType::get(llvm::ArrayRef<mlir::Type> elementTypes) {
   assert(!elementTypes.empty() && "expected at least 1 element type");
 
   // Call into a helper 'get' method in 'TypeBase' to get a uniqued instance
   // of this type. The first parameter is the context to unique in. The

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

lowerOpToLoops(op, operands, rewriter,
                      SmallVector<Value, 2> reverseIvs(llvm::reverse(loopIvs));
                      return builder.create<AffineLoadOp>(loc, input,
                                                          reverseIvs);
                    });
     return success();
   }
 };
 
-} // end anonymous namespace.
+} // 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, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, memref::MemRefDialect, StandardOpsDialect>();
   }
   void runOnFunction() final;
 };
-} // end anonymous namespace.
+} // namespace
 
 void ToyToAffineLoweringPass::runOnFunction() {
   auto function = getFunction();
 
   // We only lower the main function as we expect that all other functions have
   // been inlined.
   if (function.getName() != "main")
     return;

mlir/examples/toy/Ch7/mlir/LowerToLLVM.cpp

Value cst0 = builder.create<LLVM::ConstantOp>(
         loc, IntegerType::get(builder.getContext(), 64),
         builder.getIntegerAttr(builder.getIndexType(), 0));
     return builder.create<LLVM::GEPOp>(
         loc,
         LLVM::LLVMPointerType::get(IntegerType::get(builder.getContext(), 8)),
         globalPtr, ArrayRef<Value>({cst0, cst0}));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ToyToLLVMLoweringPass
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ToyToLLVMLoweringPass
     : public PassWrapper<ToyToLLVMLoweringPass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<LLVM::LLVMDialect, scf::SCFDialect>();
   }
   void runOnOperation() final;
 };
-} // end anonymous namespace
+} // namespace
 
 void ToyToLLVMLoweringPass::runOnOperation() {
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering. For this lowering, we are only targeting
   // the LLVM dialect.
   LLVMConversionTarget target(getContext());
   target.addLegalOp<ModuleOp>();
 

mlir/examples/toy/Ch7/mlir/ShapeInferencePass.cpp

public:
   /// A utility method that returns if the given operation has a dynamically
   /// shaped result.
   static bool returnsDynamicShape(Operation *op) {
     return llvm::any_of(op->getResultTypes(), [](Type resultType) {
       return !resultType.isa<RankedTensorType>();
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 /// Create a Shape Inference pass.
 std::unique_ptr<mlir::Pass> mlir::toy::createShapeInferencePass() {
   return std::make_unique<ShapeInferencePass>();
 }

mlir/examples/toy/Ch7/mlir/ToyCombine.cpp

 #include "toy/Dialect.h"
 #include <numeric>
 using namespace mlir;
 using namespace toy;
 
 namespace {
 /// Include the patterns defined in the Declarative Rewrite framework.
 #include "ToyCombine.inc"
-} // end anonymous namespace
+} // namespace
 
 /// Fold constants.
 OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) { return value(); }
 
 /// Fold struct constants.
 OpFoldResult StructConstantOp::fold(ArrayRef<Attribute> operands) {
   return value();
 }

mlir/include/mlir/Analysis/AffineAnalysis.h

 
 /// 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);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_AFFINE_ANALYSIS_H

mlir/include/mlir/Analysis/AffineStructures.h

 ///
 /// 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);
 
-} // end namespace mlir.
+} // namespace mlir.
 
 #endif // MLIR_ANALYSIS_AFFINESTRUCTURES_H

mlir/include/mlir/Analysis/AliasAnalysis.h

public:
     ModRefResult getModRef(Operation *op, Value location) final {
       return impl.getModRef(op, location);
     }
 
   private:
     ImplT impl;
   };
 };
-} // end namespace detail
+} // namespace detail
 
 //===----------------------------------------------------------------------===//
 // AliasAnalysis
 //===----------------------------------------------------------------------===//
 
 /// This class represents the main alias analysis interface in MLIR. It
 /// functions as an aggregate of various different alias analysis
 /// implementations. This aggregation allows for utilizing the strengths of
public:
   /// Return the modify-reference behavior of `op` on `location`.
   ModRefResult getModRef(Operation *op, Value location);
 
 private:
   /// A set of internal alias analysis implementations.
   SmallVector<std::unique_ptr<Concept>, 4> aliasImpls;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_ALIASANALYSIS_H_

mlir/include/mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h

 class LocalAliasAnalysis {
 public:
   /// Given two values, return their aliasing behavior.
   AliasResult alias(Value lhs, Value rhs);
 
   /// Return the modify-reference behavior of `op` on `location`.
   ModRefResult getModRef(Operation *op, Value location);
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_

mlir/include/mlir/Analysis/CallGraph.h

 private:
   /// The set of nodes within the callgraph.
   NodeMapT nodes;
 
   /// A special node used to indicate an external edges.
   CallGraphNode externalNode;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 // Provide graph traits for traversing call graphs using standard graph
 // traversals.
 template <> struct GraphTraits<const mlir::CallGraphNode *> {
   using NodeRef = mlir::CallGraphNode *;
   static NodeRef getEntryNode(NodeRef node) { return node; }
 
static NodeRef getEntryNode(const mlir::CallGraph *cg) {
     return cg->getExternalNode();
   }
 
   // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
   using nodes_iterator = mlir::CallGraph::iterator;
   static nodes_iterator nodes_begin(mlir::CallGraph *cg) { return cg->begin(); }
   static nodes_iterator nodes_end(mlir::CallGraph *cg) { return cg->end(); }
 };
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_ANALYSIS_CALLGRAPH_H

mlir/include/mlir/Analysis/DataFlowAnalysis.h

private:
 
   /// An allocator used for new lattice elements.
   llvm::SpecificBumpPtrAllocator<LatticeElement<ValueT>> allocator;
 
   /// The MLIRContext of this solver.
   MLIRContext *context;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_DATAFLOWANALYSIS_H

mlir/include/mlir/Analysis/Liveness.h

private:
   ValueSetT inValues;
 
   /// The set of all live out values.
   ValueSetT outValues;
 
   friend class Liveness;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_LIVENESS_H

mlir/include/mlir/Analysis/LoopAnalysis.h

 /// Linalg, Affine and SCF. For the sake of genericity, it does not return
 /// specific enum values for the combiner operations since its goal is also
 /// matching reductions without pre-defined semantics in core MLIR. It's up to
 /// each client to make sense out of the list of combiner operations. It's also
 /// up to each client to check for additional invariants on the expected
 /// reductions not covered by this generic matching.
 Value matchReduction(ArrayRef<BlockArgument> iterCarriedArgs, unsigned redPos,
                      SmallVectorImpl<Operation *> &combinerOps);
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_LOOP_ANALYSIS_H

mlir/include/mlir/Analysis/NestedMatcher.h

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

mlir/include/mlir/Analysis/NumberOfExecutions.h

private:
   /// Number of `block` parent region invocations *each time* parent operation
   /// is executed.
   Optional<int64_t> numberOfRegionInvocations;
 
   /// Number of `block` executions *each time* parent region is invoked.
   Optional<int64_t> numberOfBlockExecutions;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H

mlir/include/mlir/Analysis/SliceAnalysis.h

getSlice(Operation *op,
          TransitiveFilter backwardFilter = nullptr /* pass-through*/,
          TransitiveFilter forwardFilter = nullptr /* pass-through*/);
 
 /// Multi-root DAG topological sort.
 /// Performs a topological sort of the Operation in the `toSort` SetVector.
 /// Returns a topologically sorted SetVector.
 SetVector<Operation *> topologicalSort(const SetVector<Operation *> &toSort);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_SLICEANALYSIS_H_

mlir/include/mlir/Analysis/Utils.h

 /// number of constraints.
 IntegerSet simplifyIntegerSet(IntegerSet set);
 
 /// Returns the innermost common loop depth for the set of operations in 'ops'.
 unsigned getInnermostCommonLoopDepth(
     ArrayRef<Operation *> ops,
     SmallVectorImpl<AffineForOp> *surroundingLoops = nullptr);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_ANALYSIS_UTILS_H

mlir/include/mlir/CAPI/Utils.h

public:
 
   uint64_t current_pos() const override { return pos; }
 
 private:
   std::function<void(MlirStringRef, void *)> callback;
   void *opaqueData;
   uint64_t pos;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 #endif // MLIR_CAPI_UTILS_H

mlir/include/mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h

 class RewritePatternSet;
 class Pass;
 
 namespace arith {
 void populateArithmeticToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                 RewritePatternSet &patterns);
 
 std::unique_ptr<Pass> createConvertArithmeticToLLVMPass();
-} // end namespace arith
-} // end namespace mlir
+} // namespace arith
+} // namespace mlir
 
 #endif // MLIR_CONVERSION_ARITHMETICTOLLVM_ARITHMETICTOLLVM_H

mlir/include/mlir/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.h

 class RewritePatternSet;
 class Pass;
 
 namespace arith {
 void populateArithmeticToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                        RewritePatternSet &patterns);
 
 std::unique_ptr<Pass> createConvertArithmeticToSPIRVPass();
-} // end namespace arith
-} // end namespace mlir
+} // namespace arith
+} // namespace mlir
 
 #endif // MLIR_CONVERSION_ARITHMETICTOSPIRV_ARITHMETICTOSPIRV_H

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

 class MLIRContext;
 class Value;
 class Operation;
 class RewritePatternSet;
 using OwningRewritePatternList = RewritePatternSet;
 
 namespace scf {
 class ForOp;
-} // end namespace scf
+} // 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

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

private:
   AffineMap map;
 
   AffineBound(AffineForOp op, unsigned opStart, unsigned opEnd, AffineMap map)
       : op(op), opStart(opStart), opEnd(opEnd), map(map) {}
 
   friend class AffineForOp;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif

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

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

mlir/include/mlir/Dialect/Arithmetic/IR/Arithmetic.h

public:
 
   inline int64_t value() {
     return arith::ConstantOp::getValue().cast<IntegerAttr>().getInt();
   }
 
   static bool classof(Operation *op);
 };
 
-} // end namespace arith
-} // end namespace mlir
+} // namespace arith
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Utility Functions
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace arith {
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
 /// comparison predicates.
 bool applyCmpPredicate(arith::CmpIPredicate predicate, const APInt &lhs,
                        const APInt &rhs);
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
 /// comparison predicates.
 bool applyCmpPredicate(arith::CmpFPredicate predicate, const APFloat &lhs,
                        const APFloat &rhs);
 
-} // end namespace arith
-} // end namespace mlir
+} // namespace arith
+} // namespace mlir
 
 #endif // MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_

mlir/include/mlir/Dialect/Arithmetic/Transforms/Passes.h

 //===- Passes.h - Pass Entrypoints ------------------------------*- 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_ARITHMETIC_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace arith {
 
 /// Add patterns to bufferize Arithmetic ops.
 void populateArithmeticBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns);
 

 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
 
-} // end namespace arith
-} // end namespace mlir
+} // namespace arith
+} // namespace mlir
 
 #endif // MLIR_DIALECT_ARITHMETIC_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/Bufferization/Transforms/Bufferize.h

 void populateBufferizeMaterializationLegality(ConversionTarget &target);
 
 /// Populate patterns to eliminate bufferize materializations.
 ///
 /// In particular, these are the tensor_load/buffer_cast ops.
 void populateEliminateBufferizeMaterializationsPatterns(
     BufferizeTypeConverter &typeConverter, RewritePatternSet &patterns);
 
-} // end namespace bufferization
-} // end namespace mlir
+} // namespace bufferization
+} // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_BUFFERIZE_H

mlir/include/mlir/Dialect/Bufferization/Transforms/Passes.h

 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
 
-} // end namespace bufferization
-} // end namespace mlir
+} // namespace bufferization
+} // namespace mlir
 
 #endif // MLIR_DIALECT_BUFFERIZATION_TRANSFORMS_PASSES_H

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

public:
   /// C += A*B. This function returns which operand in the given equation is
   /// held by this type. String returned can be one of"AOp", "BOp" and "COp".
   StringRef getOperand() const;
 };
 
 // Adds a `gpu.async.token` to the front of the argument list.
 void addAsyncDependency(Operation *op, Value token);
 
-} // end namespace gpu
-} // end namespace mlir
+} // namespace gpu
+} // namespace mlir
 
 #include "mlir/Dialect/GPU/GPUOpsEnums.h.inc"
 
 #include "mlir/Dialect/GPU/GPUOpsDialect.h.inc"
 
 #include "mlir/Dialect/GPU/GPUOpInterfaces.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/GPU/GPUOps.h.inc"
 
 #endif // MLIR_DIALECT_GPU_GPUDIALECT_H

mlir/include/mlir/Dialect/GPU/MemoryPromotion.h

 namespace gpu {
 class GPUFuncOp;
 }
 
 /// Promotes a function argument to workgroup memory in the given function. The
 /// copies will be inserted in the beginning and in the end of the function.
 void promoteToWorkgroupMemory(gpu::GPUFuncOp op, unsigned arg);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_GPU_MEMORYPROMOTION_H

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

 
 /// Sets the mapping attribute of a scf.parallel operation. Verifies that the
 /// mapping passed is valid.
 /// - the number of DimMapperAttr provided is same as the number of loops of
 ///   the `ploopOp`.
 /// - the mapping does not map multiple loops to the same processor.
 LogicalResult setMappingAttr(scf::ParallelOp ploopOp,
                              ArrayRef<ParallelLoopDimMapping> mapping);
-} // end namespace gpu
+} // namespace gpu
 
 /// Maps the parallel loops found in the given function to workgroups. The first
 /// loop encountered will be mapped to the global workgroup and the second loop
 /// encountered to the local workgroup. Within each mapping, the first three
 /// dimensions are mapped to x/y/z hardware ids and all following dimensions are
 /// mapped to sequential loops.
 void greedilyMapParallelSCFToGPU(Region &region);
 
-} // end namespace mlir
+} // namespace mlir
 #endif // MLIR_DIALECT_GPU_PARALLELLOOPMAPPER_H

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

 #include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.h.inc"
 
 namespace llvm {
 class Type;
 class LLVMContext;
 namespace sys {
 template <bool mt_only>
 class SmartMutex;
-} // end namespace sys
-} // end namespace llvm
+} // namespace sys
+} // namespace llvm
 
 namespace mlir {
 namespace LLVM {
 class LLVMDialect;
 class LoopOptionsAttrBuilder;
 
 namespace detail {
 struct LLVMTypeStorage;

 private:
   template <typename T>
   LoopOptionsAttrBuilder &setOption(LoopOptionCase tag, Optional<T> value);
 
   friend class LoopOptionsAttr;
   SmallVector<LoopOptionsAttr::OptionValuePair> options;
 };
 
-} // end namespace LLVM
-} // end namespace mlir
+} // namespace LLVM
+} // namespace mlir
 
 #endif // MLIR_DIALECT_LLVMIR_LLVMDIALECT_H_

mlir/include/mlir/Dialect/MemRef/Utils/MemRefUtils.h

 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 
 namespace mlir {
 
 /// Finds a single dealloc operation for the given allocated value. If there
 /// are > 1 deallocates for `allocValue`, returns None, else returns the single
 /// deallocate if it exists or nullptr.
 llvm::Optional<Operation *> findDealloc(Value allocValue);
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_MEMREF_UTILS_MEMREFUTILS_H

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

 /// 2.9.3. worker
 /// 2.9.4. vector
 ///
 /// Value can be combined bitwise to reflect the mapping applied to the
 /// construct. e.g. `acc.loop gang vector`, the `gang` and `vector` could be
 /// combined and the final mapping value would be 5 (4 | 1).
 enum OpenACCExecMapping { NONE = 0, VECTOR = 1, WORKER = 2, GANG = 4 };
 
-} // end namespace acc
-} // end namespace mlir
+} // namespace acc
+} // namespace mlir
 
 #endif // MLIR_DIALECT_OPENACC_OPENACC_H_

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

 /// (like for reductions). Does not take the initial value of reductions or
 /// expect the body building functions to return their current value.
 /// The built nested scf::For are captured in `capturedLoops` when non-null.
 LoopNest buildLoopNest(OpBuilder &builder, Location loc, ValueRange lbs,
                        ValueRange ubs, ValueRange steps,
                        function_ref<void(OpBuilder &, Location, ValueRange)>
                            bodyBuilder = nullptr);
 
-} // end namespace scf
-} // end namespace mlir
+} // namespace scf
+} // namespace mlir
 #endif // MLIR_DIALECT_SCF_H_

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

 class Value;
 class AffineExpr;
 class Operation;
 
 namespace scf {
 class IfOp;
 class ForOp;
 class ParallelOp;
-} // end namespace scf
+} // namespace scf
 
 /// Create a clone of `loop` with `newIterOperands` added as new initialization
 /// values and `newYieldedValues` added as new yielded values. The returned
 /// ForOp has `newYieldedValues.size()` new result values.  The `loop` induction
 /// variable and `newIterOperands` are remapped to the new induction variable
 /// and the new entry block arguments respectively.
 ///
 /// Additionally, if `replaceLoopResults` is true, all uses of

 /// from scf.for or scf.parallel loop.
 /// if `loopFilter` is passed, the filter determines which loop to consider.
 /// Other induction variables are ignored.
 Optional<std::pair<AffineExpr, AffineExpr>>
 getSCFMinMaxExpr(Value value, SmallVectorImpl<Value> &dims,
                  SmallVectorImpl<Value> &symbols,
                  llvm::function_ref<bool(Operation *)> loopFilter = nullptr);
 
-} // end namespace mlir
+} // namespace mlir
 #endif // MLIR_DIALECT_SCF_UTILS_H_

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

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

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVEnums.h

 ArrayRef<Capability> getDirectImpliedCapabilities(Capability cap);
 /// Returns the recursively implied capabilities for the given capability. These
 /// capabilities are implicitly declared by the given capability. Compared to
 /// the above function, this function collects implied capabilities recursively:
 /// if an implicitly declared capability implicitly declares a third one, the
 /// third one will also be returned.
 SmallVector<Capability, 0> getRecursiveImpliedCapabilities(Capability cap);
 
-} // end namespace spirv
-} // end namespace mlir
+} // namespace spirv
+} // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_IR_SPIRVENUMS_H_

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

public:
   Type getElementType() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<StorageClass> storage = llvm::None);
 };
 
-} // end namespace spirv
-} // end namespace mlir
+} // namespace spirv
+} // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_

mlir/include/mlir/Dialect/Shape/Transforms/Passes.h

 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_SHAPE_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/StandardOps/IR/Ops.h

 Value getIdentityValue(AtomicRMWKind op, Type resultType, OpBuilder &builder,
                        Location loc);
 
 /// Returns the value obtained by applying the reduction operation kind
 /// associated with a binary AtomicRMWKind op to `lhs` and `rhs`.
 Value getReductionOp(AtomicRMWKind op, OpBuilder &builder, Location loc,
                      Value lhs, Value rhs);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_IR_STANDARDOPS_IR_OPS_H

mlir/include/mlir/Dialect/StandardOps/Transforms/DecomposeCallGraphTypes.h

 
 /// Populates the patterns needed to drive the conversion process for
 /// decomposing call graph types with the given `ValueDecomposer`.
 void populateDecomposeCallGraphTypesPatterns(MLIRContext *context,
                                              TypeConverter &typeConverter,
                                              ValueDecomposer &decomposer,
                                              RewritePatternSet &patterns);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_TRANSFORMS_DECOMPOSECALLGRAPHTYPES_H

mlir/include/mlir/Dialect/StandardOps/Transforms/FuncConversions.h

bool isLegalForReturnOpTypeConversionPattern(Operation *op,
                                              bool returnOpAlwaysLegal = false);
 
 /// Return true if op is neither BranchOpInterface nor ReturnLike.
 ///
 /// TODO Try to get rid of this function and invert the meaning of
 /// `isLegalForBranchOpInterfaceTypeConversionPattern` and
 /// `isLegalForReturnOpTypeConversionPattern`.
 bool isNotBranchOpInterfaceOrReturnLikeOp(Operation *op);
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_TRANSFORMS_FUNCCONVERSIONS_H_

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.h

 #ifndef MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
-} // end namespace bufferization
+} // namespace bufferization
 
 class GlobalCreator;
 class RewritePatternSet;
 using OwningRewritePatternList = RewritePatternSet;
 
 void populateStdBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns);

 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/StandardOps/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARD_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/StandardOps/Utils/Utils.h

struct ArithBuilder {
   Value select(Value cmp, Value lhs, Value rhs);
   Value sgt(Value lhs, Value rhs);
   Value slt(Value lhs, Value rhs);
 
 private:
   OpBuilder &b;
   Location loc;
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_UTILS_UTILS_H

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

 //===- Passes.h - Pass Entrypoints ------------------------------*- 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_TENSOR_TRANSFORMS_PASSES_H_
 #define MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 namespace bufferization {
 class BufferizeTypeConverter;
-} // end namespace bufferization
+} // namespace bufferization
 
 class RewritePatternSet;
 using OwningRewritePatternList = RewritePatternSet;
 
 void populateTensorBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns);
 
 /// Creates an instance of `tensor` dialect bufferization pass.
 std::unique_ptr<Pass> createTensorBufferizePass();
 
 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 namespace tensor {
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
 } // namespace tensor
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_TENSOR_TRANSFORMS_PASSES_H_

mlir/include/mlir/Dialect/Tosa/IR/TosaOps.h

 #include "mlir/Dialect/Tosa/IR/TosaOpsDialect.h.inc"
 #include "mlir/Dialect/Tosa/IR/TosaStructs.h.inc"
 
 namespace mlir {
 namespace tosa {
 
 #include "mlir/Dialect/Tosa/IR/TosaInterfaces.h.inc"
 
-} // end namespace tosa
-} // end namespace mlir
+} // namespace tosa
+} // namespace mlir
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Tosa/IR/TosaOps.h.inc"
 
 #endif // MLIR_DIALECT_TOSA_IR_TOSAOPS_H

mlir/include/mlir/Dialect/Tosa/Transforms/PassDetail.h

 #include "mlir/Dialect/Tosa/IR/TosaOps.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Tosa/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_DIALECT_TOSA_TRANSFORMS_PASSDETAIL_H

mlir/include/mlir/Dialect/Traits.h

 class ResultsBroadcastableShape
     : public TraitBase<ConcreteType, ResultsBroadcastableShape> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyCompatibleOperandBroadcast(op);
   }
 };
 
-} // end namespace OpTrait
-} // end namespace mlir
+} // namespace OpTrait
+} // namespace mlir
 
 #endif // MLIR_DIALECT_TRAITS

mlir/include/mlir/Dialect/Utils/StructuredOpsUtils.h

protected:
   OpBuilder &builder;
   MLIRContext *ctx;
   Location loc;
   ArrayAttr iterators;
   SmallVector<AffineMap, 4> maps;
   Operation *op;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_UTILS_STRUCTUREDOPSUTILS_H

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

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

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

 /// over other smaller vector types in the function and avoids interfering with
 /// operations on those.
 /// This is a first approximation, it can easily be extended in the future.
 /// TODO: this could all be much simpler if we added a bit that a vector type to
 /// mark that a vector is a strict super-vector but it still does not warrant
 /// adding even 1 extra bit in the IR for now.
 bool operatesOnSuperVectorsOf(Operation &op, VectorType subVectorType);
 
-} // end namespace matcher
-} // end namespace mlir
+} // namespace matcher
+} // namespace mlir
 
 #endif // MLIR_DIALECT_VECTOR_VECTORUTILS_H_

mlir/include/mlir/ExecutionEngine/CRunnerUtils.h

struct Vector1D<T, Dim, /*IsPowerOf2=*/false> {
   }
   inline T &operator[](unsigned i) { return vector[i]; }
   inline const T &operator[](unsigned i) const { return vector[i]; }
 
 private:
   T vector[Dim];
   char padding[nextPowerOf2(sizeof(T[Dim])) - sizeof(T[Dim])];
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 // N-D vectors recurse down to 1-D.
 template <typename T, int Dim, int... Dims>
 struct Vector {
   inline Vector<T, Dims...> &operator[](unsigned i) { return vector[i]; }
   inline const Vector<T, Dims...> &operator[](unsigned i) const {
     return vector[i];
   }

mlir/include/mlir/ExecutionEngine/ExecutionEngine.h

private:
 
   /// GDB notification listener.
   llvm::JITEventListener *gdbListener;
 
   /// Perf notification listener.
   llvm::JITEventListener *perfListener;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_EXECUTIONENGINE_EXECUTIONENGINE_H_

mlir/include/mlir/ExecutionEngine/OptUtils.h

 /// initialize passes that provide target-specific information to the LLVM
 /// optimizer. `targetMachine` must outlive the returned std::function.
 std::function<llvm::Error(llvm::Module *)>
 makeLLVMPassesTransformer(llvm::ArrayRef<const llvm::PassInfo *> llvmPasses,
                           llvm::Optional<unsigned> mbOptLevel,
                           llvm::TargetMachine *targetMachine,
                           unsigned optPassesInsertPos = 0);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // LIR_EXECUTIONENGINE_OPTUTILS_H_

mlir/include/mlir/IR/AffineExprVisitor.h

inline unsigned getNumCols() const {
     return numDims + numSymbols + numLocals + 1;
   }
   inline unsigned getConstantIndex() const { return getNumCols() - 1; }
   inline unsigned getLocalVarStartIndex() const { return numDims + numSymbols; }
   inline unsigned getSymbolStartIndex() const { return numDims; }
   inline unsigned getDimStartIndex() const { return 0; }
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_AFFINE_EXPR_VISITOR_H

mlir/include/mlir/IR/AffineMap.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace mlir {
 
 namespace detail {
 struct AffineMapStorage;
-} // end namespace detail
+} // namespace detail
 
 class Attribute;
 struct LogicalResult;
 class MLIRContext;
 
 /// A multi-dimensional affine map
 /// Affine map's are immutable like Type's, and they are uniqued.
 /// Eg: (d0, d1) -> (d0/128, d0 mod 128, d1)
for (const auto &exprs : exprsList) {
     }
   }
 }
 
 inline raw_ostream &operator<<(raw_ostream &os, AffineMap map) {
   map.print(os);
   return os;
 }
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 
 // AffineExpr hash just like pointers
 template <>
 struct DenseMapInfo<mlir::AffineMap> {
   static mlir::AffineMap getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();

mlir/include/mlir/IR/AsmState.h

 
 #include <memory>
 
 namespace mlir {
 class Operation;
 
 namespace detail {
 class AsmStateImpl;
-} // end namespace detail
+} // namespace detail
 
 /// This class provides management for the lifetime of the state used when
 /// printing the IR. It allows for alleviating the cost of recomputing the
 /// internal state of the asm printer.
 ///
 /// The IR should not be mutated in-between invocations using this state, and
 /// the IR being printed must not be an parent of the IR originally used to
 /// initialize this state. This means that if a child operation is provided, a

 //===----------------------------------------------------------------------===//
 // AsmPrinter CommandLine Options
 //===----------------------------------------------------------------------===//
 
 /// Register a set of useful command-line options that can be used to configure
 /// various flags within the AsmPrinter.
 void registerAsmPrinterCLOptions();
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_ASMSTATE_H_

mlir/include/mlir/IR/AttributeSupport.h

 };
 
 //===----------------------------------------------------------------------===//
 // AttributeStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 class AttributeUniquer;
-} // end namespace detail
+} // namespace detail
 
 /// Base storage class appearing in an attribute. Derived storage classes should
 /// only be constructed within the context of the AttributeUniquer.
 class alignas(8) AttributeStorage : public StorageUniquer::BaseStorage {
   friend detail::AttributeUniquer;
   friend StorageUniquer;
 
 public:

 
 private:
   /// Initialize the given attribute storage instance.
   static void initializeAttributeStorage(AttributeStorage *storage,
                                          MLIRContext *ctx, TypeID attrID);
 };
 } // namespace detail
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif

mlir/include/mlir/IR/Attributes.h

private:
   static typename InterfaceBase::Concept *getInterfaceFor(Attribute attr) {
     return attr.getAbstractAttribute().getInterface<ConcreteType>();
   }
 
   /// Allow access to 'getInterfaceFor'.
   friend InterfaceBase;
 };
 
-} // end namespace mlir.
+} // namespace mlir.
 
 namespace llvm {
 
 // Attribute hash just like pointers.
 template <> struct DenseMapInfo<mlir::Attribute> {
   static mlir::Attribute getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));

mlir/include/mlir/IR/Block.h

 #ifndef MLIR_IR_BLOCK_H
 #define MLIR_IR_BLOCK_H
 
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/Visitors.h"
 
 namespace llvm {
 class BitVector;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class TypeRange;
 template <typename ValueRangeT>
 class ValueTypeRange;
 
 /// `Block` represents an ordered list of `Operation`s.
 class Block : public IRObjectWithUseList<BlockOperand>,
private:
   /// This is the list of arguments to the block.
   std::vector<BlockArgument> arguments;
 
   Block(Block &) = delete;
   void operator=(Block &) = delete;
 
   friend struct llvm::ilist_traits<Block>;
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_BLOCK_H

mlir/include/mlir/IR/BlockAndValueMapping.h

Value lookupOrValue(Value from, Value value) const {
     auto it = valueMap.find(from);
     return it != valueMap.end() ? it->second : value;
   }
 
   DenseMap<Value, Value> valueMap;
   DenseMap<Block *, Block *> blockMap;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_BLOCKANDVALUEMAPPING_H

mlir/include/mlir/IR/BlockSupport.h

public:
   /// Initializes the iterator to the specified filter iterator.
   op_iterator(op_filter_iterator<OpT, IteratorT> it)
       : llvm::mapped_iterator<op_filter_iterator<OpT, IteratorT>,
                               OpT (*)(Operation &)>(it, &unwrap) {}
 
   /// Allow implicit conversion to the underlying block iterator.
   operator const IteratorT &() const { return this->wrapped(); }
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 namespace llvm {
 
 /// Provide support for hashing successor ranges.
 template <>
 struct DenseMapInfo<mlir::SuccessorRange> {
   static mlir::SuccessorRange getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<mlir::BlockOperand *>::getEmptyKey();
protected:
   using node_type = ilist_node_impl<OptionsT>;
 
   static node_type *getNodePtr(pointer N);
   static const node_type *getNodePtr(const_pointer N);
 
   static pointer getValuePtr(node_type *N);
   static const_pointer getValuePtr(const node_type *N);
 };
-} // end namespace ilist_detail
+} // namespace ilist_detail
 
 template <> struct ilist_traits<::mlir::Operation> {
   using Operation = ::mlir::Operation;
   using op_iterator = simple_ilist<Operation>::iterator;
 
   static void deleteNode(Operation *op);
   void addNodeToList(Operation *op);
   void removeNodeFromList(Operation *op);
struct ilist_traits<::mlir::Block> : public ilist_alloc_traits<::mlir::Block> {
   void removeNodeFromList(Block *block);
   void transferNodesFromList(ilist_traits<Block> &otherList,
                              block_iterator first, block_iterator last);
 
 private:
   mlir::Region *getParentRegion();
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_IR_BLOCK_SUPPORT_H

mlir/include/mlir/IR/BuiltinAttributeInterfaces.h

 auto ElementsAttr::try_value_begin() const
     -> DefaultValueCheckT<T, Optional<iterator<T>>> {
   FailureOr<detail::ElementsAttrIndexer> indexer =
       getValuesImpl(TypeID::get<T>());
   if (failed(indexer))
     return llvm::None;
   return iterator<T>(std::move(*indexer), 0);
 }
-} // end namespace mlir.
+} // namespace mlir.
 
 #endif // MLIR_IR_BUILTINATTRIBUTEINTERFACES_H

mlir/include/mlir/IR/BuiltinAttributes.h

 inline bool operator!=(StringAttr lhs, StringRef rhs) { return !(lhs == rhs); }
 inline bool operator==(StringRef lhs, StringAttr rhs) {
   return rhs.getValue() == lhs;
 }
 inline bool operator!=(StringRef lhs, StringAttr rhs) { return !(lhs == rhs); }
 
 inline Type StringAttr::getType() const { return Attribute::getType(); }
 
-} // end namespace mlir
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Attribute Utilities
 //===----------------------------------------------------------------------===//
 
 namespace llvm {
 
 template <>

mlir/include/mlir/IR/BuiltinOps.h

 // TODO: Remove this class in favor of using OwningOpRef directly.
 class OwningModuleRef : public OwningOpRef<ModuleOp> {
 public:
   using OwningOpRef<ModuleOp>::OwningOpRef;
   OwningModuleRef() = default;
   OwningModuleRef(OwningOpRef<ModuleOp> &&other)
       : OwningOpRef<ModuleOp>(std::move(other)) {}
 };
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 /// Allow stealing the low bits of FuncOp.
 template <>
 struct PointerLikeTypeTraits<mlir::FuncOp> {
   static inline void *getAsVoidPointer(mlir::FuncOp val) {
     return const_cast<void *>(val.getAsOpaquePointer());
   }
public:
   static inline void *getAsVoidPointer(mlir::ModuleOp val) {
     return const_cast<void *>(val.getAsOpaquePointer());
   }
   static inline mlir::ModuleOp getFromVoidPointer(void *p) {
     return mlir::ModuleOp::getFromOpaquePointer(p);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_IR_BUILTINOPS_H_

mlir/include/mlir/IR/BuiltinTypes.h

public:
   /// Returns the memory space in which data referred to by this memref resides.
   Attribute getMemorySpace() const;
 
   /// [deprecated] Returns the memory space in old raw integer representation.
   /// New `Attribute getMemorySpace()` method should be used instead.
   unsigned getMemorySpaceAsInt() const;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Tablegen Type Declarations
 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/IR/BuiltinTypes.h.inc"
 

 
 /// Return true if the layout for `t` is compatible with strided semantics.
 bool isStrided(MemRefType t);
 
 /// Return the layout map in strided linear layout AffineMap form.
 /// Return null if the layout is not compatible with a strided layout.
 AffineMap getStridedLinearLayoutMap(MemRefType t);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_BUILTINTYPES_H

mlir/include/mlir/IR/Diagnostics.h

 
 #include "mlir/IR/Location.h"
 #include <functional>
 
 namespace llvm {
 class MemoryBuffer;
 class SMLoc;
 class SourceMgr;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class DiagnosticEngine;
 struct LogicalResult;
 class MLIRContext;
 class Operation;
 class OperationName;
 class OpPrintingFlags;
 class Type;
 class Value;
 
 namespace detail {
 struct DiagnosticEngineImpl;
-} // end namespace detail
+} // namespace detail
 
 /// Defines the different supported severity of a diagnostic.
 enum class DiagnosticSeverity {
   Note,
   Warning,
   Error,
   Remark,
 };

 };
 
 //===----------------------------------------------------------------------===//
 // SourceMgrDiagnosticHandler
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct SourceMgrDiagnosticHandlerImpl;
-} // end namespace detail
+} // namespace detail
 
 /// This class is a utility diagnostic handler for use with llvm::SourceMgr.
 class SourceMgrDiagnosticHandler : public ScopedDiagnosticHandler {
 public:
   /// This type represents a functor used to filter out locations when printing
   /// a diagnostic. It should return true if the provided location is okay to
   /// display, false otherwise. If all locations in a diagnostic are filtered
   /// out, the first location is used as the sole location. When deciding

 };
 
 //===----------------------------------------------------------------------===//
 // SourceMgrDiagnosticVerifierHandler
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct SourceMgrDiagnosticVerifierHandlerImpl;
-} // end namespace detail
+} // namespace detail
 
 /// This class is a utility diagnostic handler for use with llvm::SourceMgr that
 /// verifies that emitted diagnostics match 'expected-*' lines on the
 /// corresponding line of the source file.
 class SourceMgrDiagnosticVerifierHandler : public SourceMgrDiagnosticHandler {
 public:
   SourceMgrDiagnosticVerifierHandler(llvm::SourceMgr &srcMgr, MLIRContext *ctx,
                                      raw_ostream &out);

 };
 
 //===----------------------------------------------------------------------===//
 // ParallelDiagnosticHandler
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct ParallelDiagnosticHandlerImpl;
-} // end namespace detail
+} // namespace detail
 
 /// This class is a utility diagnostic handler for use when multi-threading some
 /// part of the compiler where diagnostics may be emitted. This handler ensures
 /// a deterministic ordering to the emitted diagnostics that mirrors that of a
 /// single-threaded compilation.
 class ParallelDiagnosticHandler {
 public:
   ParallelDiagnosticHandler(MLIRContext *ctx);

mlir/include/mlir/IR/Dialect.h

public:
   /// This is used for the dialect to provide an alternative way to parse custom
   /// operations, including unregistered ones.
   using ParseOpHook =
       function_ref<ParseResult(OpAsmParser &parser, OperationState &result)>;
 
   virtual ~Dialect();
 
   /// Utility function that returns if the given string is a valid dialect
-  /// namespace.
+  /// namespace
   static bool isValidNamespace(StringRef str);
 
   MLIRContext *getContext() const { return context; }
 
   StringRef getNamespace() const { return name; }
 
   /// Returns the unique identifier that corresponds to this dialect.
   TypeID getTypeID() const { return dialectID; }

mlir/include/mlir/IR/DialectImplementation.h

auto elementParser = [&]() {
       return success();
     };
     if (parser.parseCommaSeparatedList(elementParser))
       return failure();
     return elements;
   }
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_DIALECTIMPLEMENTATION_H

mlir/include/mlir/IR/DialectInterface.h

public:
   using Base = DialectInterfaceBase<ConcreteType, BaseT>;
 
   /// Get a unique id for the derived interface type.
   static TypeID getInterfaceID() { return TypeID::get<ConcreteType>(); }
 
 protected:
   DialectInterfaceBase(Dialect *dialect) : BaseT(dialect, getInterfaceID()) {}
 };
-} // end namespace detail
+} // namespace detail
 
 /// This class represents an interface overridden for a single dialect.
 class DialectInterface {
 public:
   virtual ~DialectInterface();
 
   /// The base class used for all derived interface types. This class provides
   /// utilities necessary for registration.

mlir/include/mlir/IR/Dominance.h

protected:
   /// "hasSSADominance" bit. This map does not contain dominator trees for
   /// single block CFG regions, but we do want to cache the "hasSSADominance"
   /// bit for them. We may also not have computed the DomTree yet. In either
   /// case, the DomTree is just null.
   ///
   mutable DenseMap<Region *, llvm::PointerIntPair<DomTree *, 1, bool>>
       dominanceInfos;
 };
-} // end namespace detail
+} // namespace detail
 
 /// A class for computing basic dominance information. Note that this
 /// class is aware of different types of regions and returns a
 /// region-kind specific concept of dominance. See RegionKindInterface.
 class DominanceInfo : public detail::DominanceInfoBase</*IsPostDom=*/false> {
 public:
   using super::super;
 
public:
   }
 
   /// Return true if the specified block A postdominates block B.
   bool postDominates(Block *a, Block *b) {
     return a == b || properlyPostDominates(a, b);
   }
 };
 
-} //  end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 
 /// DominatorTree GraphTraits specialization so the DominatorTree can be
 /// iterated by generic graph iterators.
 template <>
 struct GraphTraits<mlir::DominanceInfoNode *> {
   using ChildIteratorType = mlir::DominanceInfoNode::const_iterator;
struct GraphTraits<const mlir::DominanceInfoNode *> {
   using ChildIteratorType = mlir::DominanceInfoNode::const_iterator;
   using NodeRef = const mlir::DominanceInfoNode *;
 
   static NodeRef getEntryNode(NodeRef N) { return N; }
   static inline ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
   static inline ChildIteratorType child_end(NodeRef N) { return N->end(); }
 };
 
-} // end namespace llvm
+} // namespace llvm
 #endif

mlir/include/mlir/IR/FunctionSupport.h

Attribute FunctionLike<ConcreteType>::removeResultAttr(unsigned index,
   Attribute removedAttr = attributes.erase(name);
 
   // If the attribute was removed, then update the result dictionary.
   if (removedAttr)
     setResultAttrs(index, attributes.getDictionary(removedAttr.getContext()));
   return removedAttr;
 }
 
-} // end namespace OpTrait
+} // namespace OpTrait
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_FUNCTIONSUPPORT_H

mlir/include/mlir/IR/Identifier.h

 #define MLIR_IR_IDENTIFIER_H
 
 #include "mlir/IR/BuiltinAttributes.h"
 
 namespace mlir {
 /// NOTICE: Identifier is deprecated and usages of it should be replaced with
 /// StringAttr.
 using Identifier = StringAttr;
-} // end namespace mlir
+} // namespace mlir
 
 #endif

mlir/include/mlir/IR/IntegerSet.h

 
 #include "mlir/IR/AffineExpr.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 
 namespace detail {
 struct IntegerSetStorage;
-} // end namespace detail
+} // namespace detail
 
 class MLIRContext;
 
 /// An integer set representing a conjunction of one or more affine equalities
 /// and inequalities. An integer set in the IR is immutable like the affine map,
 /// but integer sets are not unique'd unless the number of constraints in them
 /// is below `kUniquingThreshold`. The affine expressions that make up the
 /// equalities and inequalities of an integer set are themselves unique and are
private:
   ImplType *set;
 };
 
 // Make AffineExpr hashable.
 inline ::llvm::hash_code hash_value(IntegerSet arg) {
   return ::llvm::hash_value(arg.set);
 }
 
-} // end namespace mlir
+} // namespace mlir
 namespace llvm {
 
 // IntegerSet hash just like pointers.
 template <> struct DenseMapInfo<mlir::IntegerSet> {
   static mlir::IntegerSet getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::IntegerSet(static_cast<mlir::IntegerSet::ImplType *>(pointer));
   }

mlir/include/mlir/IR/Location.h

inline raw_ostream &operator<<(raw_ostream &os, const Location &loc) {
   return os;
 }
 
 // Make Location hashable.
 inline ::llvm::hash_code hash_value(Location arg) {
   return hash_value(arg.impl);
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Tablegen Attribute Declarations
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/IR/BuiltinLocationAttributes.h.inc"
 

mlir/include/mlir/IR/MLIRContext.h

 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/TypeID.h"
 #include <functional>
 #include <memory>
 #include <vector>
 
 namespace llvm {
 class ThreadPool;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class DebugActionManager;
 class DiagnosticEngine;
 class Dialect;
 class DialectRegistry;
 class InFlightDiagnostic;
 class Location;

 // MLIRContext CommandLine Options
 //===----------------------------------------------------------------------===//
 
 /// Register a set of useful command-line options that can be used to configure
 /// various flags within the MLIRContext. These flags are used when constructing
 /// an MLIR context for initialization.
 void registerMLIRContextCLOptions();
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_MLIRCONTEXT_H

mlir/include/mlir/IR/Matchers.h

bool match(Operation *op) {
     enumerate(operandMatchers, [&](size_t index, auto &matcher) {
       res &= matchOperandOrValueAtIndex(op, index, matcher);
     });
     return res;
   }
   std::tuple<OperandMatchers...> operandMatchers;
 };
 
-} // end namespace detail
+} // namespace detail
 
 /// Matches a constant foldable operation.
 inline detail::constant_op_matcher m_Constant() {
   return detail::constant_op_matcher();
 }
 
 /// Matches a value from a constant foldable operation and writes the value to
 /// bind_value.

 }
 
 namespace matchers {
 inline auto m_Any() { return detail::AnyValueMatcher(); }
 inline auto m_Any(Value *val) { return detail::AnyCapturedValueMatcher(val); }
 inline auto m_Val(Value v) { return detail::PatternMatcherValue(v); }
 } // namespace matchers
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_MATCHERS_H

mlir/include/mlir/IR/OpDefinition.h

struct MultiOperandTraitBase : public TraitBase<ConcreteType, TraitType> {
   }
   operand_type_iterator operand_type_end() {
     return this->getOperation()->operand_type_end();
   }
   operand_type_range getOperandTypes() {
     return this->getOperation()->getOperandTypes();
   }
 };
-} // end namespace detail
+} // namespace detail
 
 /// This class provides the API for ops that are known to have no
 /// SSA operand.
 template <typename ConcreteType>
 class ZeroOperands : public TraitBase<ConcreteType, ZeroOperands> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyZeroOperands(op);
struct MultiRegionTraitBase : public TraitBase<ConcreteType, TraitType> {
 
   /// Region iterator access.
   region_iterator region_begin() {
     return this->getOperation()->region_begin();
   }
   region_iterator region_end() { return this->getOperation()->region_end(); }
   region_range getRegions() { return this->getOperation()->getRegions(); }
 };
-} // end namespace detail
+} // namespace detail
 
 /// This class provides APIs for ops that are known to have a single region.
 template <typename ConcreteType>
 class OneRegion : public TraitBase<ConcreteType, OneRegion> {
 public:
   Region &getRegion() { return this->getOperation()->getRegion(0); }
 
   /// Returns a range of operations within the region of this operation.
struct MultiResultTraitBase : public TraitBase<ConcreteType, TraitType> {
   }
   result_type_iterator result_type_end() {
     return this->getOperation()->result_type_end();
   }
   result_type_range getResultTypes() {
     return this->getOperation()->getResultTypes();
   }
 };
-} // end namespace detail
+} // namespace detail
 
 /// This class provides return value APIs for ops that are known to have a
 /// single result.  ResultType is the concrete type returned by getType().
 template <typename ConcreteType>
 class OneResult : public TraitBase<ConcreteType, OneResult> {
 public:
   Value getResult() { return this->getOperation()->getResult(0); }
 
void setSuccessor(Block *block, unsigned i) {
     return this->getOperation()->setSuccessor(block, i);
   }
 
   /// Successor iterator access.
   succ_iterator succ_begin() { return this->getOperation()->succ_begin(); }
   succ_iterator succ_end() { return this->getOperation()->succ_end(); }
   succ_range getSuccessors() { return this->getOperation()->getSuccessors(); }
 };
-} // end namespace detail
+} // namespace detail
 
 /// This class provides APIs for ops that are known to have a single successor.
 template <typename ConcreteType>
 class OneSuccessor : public TraitBase<ConcreteType, OneSuccessor> {
 public:
   Block *getSuccessor() { return this->getOperation()->getSuccessor(0); }
   void setSuccessor(Block *succ) {
     this->getOperation()->setSuccessor(succ, 0);
struct Tensorizable : public TraitBase<ConcreteType, Tensorizable> {
   }
 };
 
 /// Together, `Elementwise`, `Scalarizable`, `Vectorizable`, and `Tensorizable`
 /// provide an easy way for scalar operations to conveniently generalize their
 /// behavior to vectors/tensors, and systematize conversion between these forms.
 bool hasElementwiseMappableTraits(Operation *op);
 
-} // end namespace OpTrait
+} // namespace OpTrait
 
 //===----------------------------------------------------------------------===//
 // Internal Trait Utilities
 //===----------------------------------------------------------------------===//
 
 namespace op_definition_impl {
 //===----------------------------------------------------------------------===//
 // Trait Existence

 // TODO: These methods are deprecated in favor of CastOpInterface. Remove them
 // when all uses have been updated. Also, consider adding functionality to
 // CastOpInterface to be able to perform the ChainedTensorCast canonicalization
 // generically.
 Value foldCastOp(Operation *op);
 LogicalResult verifyCastOp(Operation *op,
                            function_ref<bool(Type, Type)> areCastCompatible);
 } // namespace impl
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 
 template <typename T>
 struct DenseMapInfo<
     T, std::enable_if_t<std::is_base_of<mlir::OpState, T>::value>> {
   static inline T getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return T::getFromOpaquePointer(pointer);
   }
   static inline T getTombstoneKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return T::getFromOpaquePointer(pointer);
   }
   static unsigned getHashValue(T val) {
     return hash_value(val.getAsOpaquePointer());
   }
   static bool isEqual(T lhs, T rhs) { return lhs == rhs; }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif

mlir/include/mlir/IR/OpImplementation.h

public:
   virtual void getAsmResultNames(Operation *op,
                                  OpAsmSetValueNameFn setNameFn) const {}
 
   /// Get a special name to use when printing the entry block arguments of the
   /// region contained by an operation in this dialect.
   virtual void getAsmBlockArgumentNames(Block *block,
                                         OpAsmSetValueNameFn setNameFn) const {}
 };
-} // end namespace mlir
+} // namespace mlir
 
 //===--------------------------------------------------------------------===//
 // Operation OpAsm interface.
 //===--------------------------------------------------------------------===//
 
 /// The OpAsmOpInterface, see OpAsmInterface.td for more details.
 #include "mlir/IR/OpAsmInterface.h.inc"
 
 #endif

mlir/include/mlir/IR/Operation.h

private:
   size_t numTrailingObjects(OverloadToken<Region>) const { return numRegions; }
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, const Operation &op) {
   const_cast<Operation &>(op).print(os, OpPrintingFlags().useLocalScope());
   return os;
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 /// Provide isa functionality for operation casts.
 template <typename T> struct isa_impl<T, ::mlir::Operation> {
   static inline bool doit(const ::mlir::Operation &op) {
     return T::classof(const_cast<::mlir::Operation *>(&op));
   }
 };

 template <class T>
 struct cast_convert_val<T, ::mlir::Operation, ::mlir::Operation> {
   static T doit(::mlir::Operation &val) { return T(&val); }
 };
 template <class T>
 struct cast_convert_val<T, ::mlir::Operation *, ::mlir::Operation *> {
   static T doit(::mlir::Operation *val) { return T(val); }
 };
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_IR_OPERATION_H

mlir/include/mlir/IR/OperationSupport.h

 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include "llvm/Support/TrailingObjects.h"
 #include <memory>
 
 namespace llvm {
 class BitVector;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class Dialect;
 class DictionaryAttr;
 class ElementsAttr;
 class MutableOperandRangeRange;
 class Operation;
 struct OperationState;

 std::pair<IteratorT, bool> findAttrSorted(IteratorT first, IteratorT last,
                                           StringAttr name) {
   constexpr unsigned kSmallAttributeList = 16;
   if (std::distance(first, last) > kSmallAttributeList)
     return findAttrSorted(first, last, name.strref());
   return findAttrUnsorted(first, last, name);
 }
 
-} // end namespace impl
+} // namespace impl
 
 //===----------------------------------------------------------------------===//
 // NamedAttrList
 //===----------------------------------------------------------------------===//
 
 /// NamedAttrList is array of NamedAttributes that tracks whether it is sorted
 /// and does some basic work to remain sorted.
 class NamedAttrList {
private:
   /// A flag indicating if the operand storage was dynamically allocated, as
   /// opposed to inlined into the owning operation.
   unsigned isStorageDynamic : 1;
   /// The number of operands within the storage.
   unsigned numOperands;
   /// A pointer to the operand storage.
   OpOperand *operandStorage;
 };
-} // end namespace detail
+} // namespace detail
 
 //===----------------------------------------------------------------------===//
 // OpPrintingFlags
 //===----------------------------------------------------------------------===//
 
 /// Set of flags used to control the behavior of the various IR print methods
 /// (e.g. Operation::Print).
 class OpPrintingFlags {
struct OperationEquivalence {
   static LogicalResult exactValueMatch(Value lhs, Value rhs) {
     return success(lhs == rhs);
   }
 };
 
 /// Enable Bitmask enums for OperationEquivalence::Flags.
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 template <>
 struct DenseMapInfo<mlir::OperationName> {
   static mlir::OperationName getEmptyKey() {
     void *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }

 template <>
 struct PointerLikeTypeTraits<mlir::RegisteredOperationName>
     : public PointerLikeTypeTraits<mlir::OperationName> {
   static inline mlir::RegisteredOperationName getFromVoidPointer(void *P) {
     return mlir::RegisteredOperationName::getFromOpaquePointer(P);
   }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif

mlir/include/mlir/IR/OwningOpRef.h

OpTy release() {
     std::swap(released, op);
     return released;
   }
 
 private:
   OpTy op;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_OWNINGOPREF_H

mlir/include/mlir/IR/PatternMatch.h

addImpl(ArrayRef<StringRef> debugLabels, Args &&... args) {
     pdlPatterns.mergeIn(T(std::forward<Args>(args)...));
   }
 
   MLIRContext *const context;
   NativePatternListT nativePatterns;
   PDLPatternModule pdlPatterns;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PATTERN_MATCH_H

mlir/include/mlir/IR/Region.h

private:
   static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
   /// See `llvm::detail::indexed_accessor_range_base` for details.
   static Region *dereference_iterator(const OwnerT &owner, ptrdiff_t index);
 
   /// Allow access to `offset_base` and `dereference_iterator`.
   friend RangeBaseT;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_REGION_H

mlir/include/mlir/IR/SymbolTable.h

Operation *lookupSymbol(StringRef name) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), name);
   }
   template <typename T>
   T lookupSymbol(StringRef name) {
     return dyn_cast_or_null<T>(lookupSymbol(name));
   }
 };
 
-} // end namespace OpTrait
+} // namespace OpTrait
 
 //===----------------------------------------------------------------------===//
 // Visibility parsing implementation.
 //===----------------------------------------------------------------------===//
 
 namespace impl {
 /// Parse an optional visibility attribute keyword (i.e., public, private, or
 /// nested) without quotes in a string attribute named 'attrName'.
 ParseResult parseOptionalVisibilityKeyword(OpAsmParser &parser,
                                            NamedAttrList &attrs);
-} // end namespace impl
+} // namespace impl
 
-} // end namespace mlir
+} // namespace mlir
 
 /// Include the generated symbol interfaces.
 #include "mlir/IR/SymbolInterfaces.h.inc"
 
 #endif // MLIR_IR_SYMBOLTABLE_H

mlir/include/mlir/IR/Threading.h

 /// not have multi-threading enabled, this function always processes elements
 /// sequentially.
 template <typename FuncT>
 void parallelForEachN(MLIRContext *context, size_t begin, size_t end,
                       FuncT &&func) {
   parallelForEach(context, llvm::seq(begin, end), std::forward<FuncT>(func));
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_IR_THREADING_H

mlir/include/mlir/IR/TypeSupport.h

 };
 
 //===----------------------------------------------------------------------===//
 // TypeStorage
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct TypeUniquer;
-} // end namespace detail
+} // namespace detail
 
 /// Base storage class appearing in a Type.
 class TypeStorage : public StorageUniquer::BaseStorage {
   friend detail::TypeUniquer;
   friend StorageUniquer;
 
 public:
   /// Return the abstract type descriptor for this type.
registerType(MLIRContext *ctx) {
     ctx->getTypeUniquer().registerSingletonStorageType<TypeStorage>(
         T::getTypeID(), [&](TypeStorage *storage) {
           storage->initialize(AbstractType::lookup(T::getTypeID(), ctx));
         });
   }
 };
 } // namespace detail
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif

mlir/include/mlir/IR/TypeUtilities.h

public:
   using BaseT::BaseT;
 
   /// Map the element to the iterator result type.
   Type mapElement(Value value) const;
 };
 
 using ResultElementTypeRange = iterator_range<ResultElementTypeIterator>;
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_SUPPORT_TYPEUTILITIES_H

mlir/include/mlir/IR/Types.h

 template <typename U> U Type::dyn_cast_or_null() const {
   return (impl && isa<U>()) ? U(impl) : U(nullptr);
 }
 template <typename U> U Type::cast() const {
   assert(isa<U>());
   return U(impl);
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 
 // Type hash just like pointers.
 template <> struct DenseMapInfo<mlir::Type> {
   static mlir::Type getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::Type(static_cast<mlir::Type::ImplType *>(pointer));

mlir/include/mlir/IR/Value.h

private:
   int64_t index;
 
   /// The source location of this argument.
   Location loc;
 
   /// Allow access to owner and constructor.
   friend BlockArgument;
 };
-} // end namespace detail
+} // namespace detail
 
 /// This class represents an argument of a Block.
 class BlockArgument : public Value {
 public:
   using Value::Value;
 
   static bool classof(Value value) {
     return llvm::isa<detail::BlockArgumentImpl>(value.getImpl());

 
 /// Return the result number of this op result.
 inline unsigned OpResultImpl::getResultNumber() const {
   if (const auto *outOfLineResult = dyn_cast<OutOfLineOpResult>(this))
     return outOfLineResult->getResultNumber();
   return cast<InlineOpResult>(this)->getResultNumber();
 }
 
-} // end namespace detail
+} // namespace detail
 
 /// This is a value defined by a result of an operation.
 class OpResult : public Value {
 public:
   using Value::Value;
 
   static bool classof(Value value) {
     return llvm::isa<detail::OpResultImpl>(value.getImpl());

 struct PointerLikeTypeTraits<mlir::OpResult>
     : public PointerLikeTypeTraits<mlir::Value> {
 public:
   static inline mlir::OpResult getFromVoidPointer(void *pointer) {
     return reinterpret_cast<mlir::detail::OpResultImpl *>(pointer);
   }
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif

mlir/include/mlir/IR/Verifier.h

 namespace mlir {
 struct LogicalResult;
 class Operation;
 
 /// Perform (potentially expensive) checks of invariants, used to detect
 /// compiler bugs, on this operation and any nested operations. On error, this
 /// reports the error through the MLIRContext and returns failure.
 LogicalResult verify(Operation *op);
-} //  end namespace mlir
+} // namespace mlir
 
 #endif

mlir/include/mlir/IR/Visitors.h

auto wrapperFn = [&](Operation *op) {
     return WalkResult::advance();
   };
   return detail::walk(op, function_ref<RetT(Operation *)>(wrapperFn), Order);
 }
 
 /// Utility to provide the return type of a templated walk method.
 template <typename FnT>
 using walkResultType = decltype(walk(nullptr, std::declval<FnT>()));
-} // end namespace detail
+} // namespace detail
 
 } // namespace mlir
 
 #endif

mlir/include/mlir/Interfaces/CallInterfaces.h

 #include "llvm/ADT/PointerUnion.h"
 
 namespace mlir {
 /// A callable is either a symbol, or an SSA value, that is referenced by a
 /// call-like operation. This represents the destination of the call.
 struct CallInterfaceCallable : public PointerUnion<SymbolRefAttr, Value> {
   using PointerUnion<SymbolRefAttr, Value>::PointerUnion;
 };
-} // end namespace mlir
+} // namespace mlir
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/CallInterfaces.h.inc"
 
 #endif // MLIR_INTERFACES_CALLINTERFACES_H

mlir/include/mlir/Interfaces/ControlFlowInterfaces.h

static_assert(ConcreteType::template hasTrait<ZeroResult>(),
                   "expected operation to have zero results");
     static_assert(ConcreteType::template hasTrait<ZeroSuccessor>(),
                   "expected operation to have zero successors");
     return success();
   }
 };
 } // namespace OpTrait
 
-} // end namespace mlir
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // ControlFlow Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the generated interface declarations.
 #include "mlir/Interfaces/ControlFlowInterfaces.h.inc"
 
 #endif // MLIR_INTERFACES_CONTROLFLOWINTERFACES_H

mlir/include/mlir/Interfaces/DecodeAttributesInterfaces.h

public:
   /// failure() and leaves 'output' unspecified. The default hook fails to
   /// decode.
   virtual LogicalResult decode(OpaqueElementsAttr input,
                                ElementsAttr &output) const {
     return failure();
   }
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_INTERFACES_DECODEATTRIBUTESINTERFACES_H_

mlir/include/mlir/Interfaces/FoldInterfaces.h

public:
   /// Registered hook to check if the given region, which is attached to an
   /// operation that is *not* isolated from above, should be used when
   /// materializing constants. The folder will generally materialize constants
   /// into the top-level isolated region, this allows for materializing into a
   /// lower level ancestor region if it is more profitable/correct.
   virtual bool shouldMaterializeInto(Region *region) const { return false; }
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_INTERFACES_FOLDINTERFACES_H_

mlir/include/mlir/Interfaces/SideEffectInterfaces.h

 /// memory that prevent erasing.
 bool isOpTriviallyDead(Operation *op);
 
 /// Return true if the given operation would be dead if unused, and has no side
 /// effects on memory that would prevent erasing. This is equivalent to checking
 /// `isOpTriviallyDead` if `op` was unused.
 bool wouldOpBeTriviallyDead(Operation *op);
 
-} // end namespace mlir
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // SideEffect Interfaces
 //===----------------------------------------------------------------------===//
 
 /// Include the definitions of the side effect interfaces.
 #include "mlir/Interfaces/SideEffectInterfaces.h.inc"
 
 #endif // MLIR_INTERFACES_SIDEEFFECTS_H

mlir/include/mlir/Parser.h

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include <cstddef>
 
 namespace llvm {
 class SourceMgr;
 class SMDiagnostic;
 class StringRef;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class AsmParserState;
 
 namespace detail {
 
 /// Given a block containing operations that have just been parsed, if the block
 /// contains a single operation of `ContainerOpT` type then remove it from the
opBlock->getOperations().splice(opBlock->begin(),
                                   parsedBlock->getOperations());
 
   // After splicing, verify just this operation to ensure it can properly
   // contain the operations inside of it.
   if (failed(op.verify()))
     return OwningOpRef<ContainerOpT>();
   return opRef;
 }
-} // end namespace detail
+} // namespace detail
 
 /// This parses the file specified by the indicated SourceMgr and appends parsed
 /// operations to the given block. If the block is non-empty, the operations are
 /// placed before the current terminator. If parsing is successful, success is
 /// returned. Otherwise, an error message is emitted through the error handler
 /// registered in the context, and failure is returned. If `sourceFileLoc` is
 /// non-null, it is populated with a file location representing the start of the
 /// source file that is being parsed. If `asmState` is non-null, it is populated

 /// an error message is emitted through a new SourceMgrDiagnosticHandler
 /// constructed from a new SourceMgr with a single MemoryBuffer wrapping
 /// `str`. If the passed `str` has additional tokens that were not part of the
 /// IntegerSet, a failure is returned. Diagnostics are printed on failure if
 /// `printDiagnosticInfo` is true.
 IntegerSet parseIntegerSet(llvm::StringRef str, MLIRContext *context,
                            bool printDiagnosticInfo = true);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PARSER_H

mlir/include/mlir/Parser/AsmParserState.h

 
 private:
   struct Impl;
 
   /// A pointer to the internal implementation of this class.
   std::unique_ptr<Impl> impl;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PARSER_ASMPARSERSTATE_H

mlir/include/mlir/Pass/AnalysisManager.h

isInvalidated(AnalysisT &analysis, const PreservedAnalyses &pa) {
   return analysis.isInvalidated(pa);
 }
 /// Default implementation of 'isInvalidated'.
 template <typename AnalysisT>
 std::enable_if_t<!llvm::is_detected<has_is_invalidated, AnalysisT>::value, bool>
 isInvalidated(AnalysisT &analysis, const PreservedAnalyses &pa) {
   return !pa.isPreserved<AnalysisT>();
 }
-} // end namespace analysis_impl
+} // namespace analysis_impl
 
 /// The abstract polymorphic base class representing an analysis.
 struct AnalysisConcept {
   virtual ~AnalysisConcept() = default;
 
   /// A hook used to query analyses for invalidation. Given a preserved analysis
   /// set, returns true if it should truly be invalidated. This allows for more
   /// fine-tuned invalidation in cases where an analysis wasn't explicitly
public:
   /// Returns an analysis manager for the current top-level module.
   operator AnalysisManager() { return AnalysisManager(&analyses); }
 
 private:
   /// The analyses for the owning module.
   detail::NestedAnalysisMap analyses;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PASS_ANALYSISMANAGER_H

mlir/include/mlir/Pass/Pass.h

protected:
   StringRef getName() const override { return llvm::getTypeName<PassT>(); }
 
   /// A clone method to create a copy of this pass.
   std::unique_ptr<Pass> clonePass() const override {
     return std::make_unique<PassT>(*static_cast<const PassT *>(this));
   }
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PASS_PASS_H

mlir/include/mlir/Pass/PassInstrumentation.h

 #include "mlir/Support/TypeID.h"
 
 namespace mlir {
 class Operation;
 class Pass;
 
 namespace detail {
 struct PassInstrumentorImpl;
-} // end namespace detail
+} // namespace detail
 
 /// PassInstrumentation provides several entry points into the pass manager
 /// infrastructure. Instrumentations should be added directly to a PassManager
 /// before running a pipeline.
 class PassInstrumentation {
 public:
   /// This struct represents information related to the parent pass of pipeline.
   /// It includes information that allows for effectively linking pipelines that
public:
 
   /// Add the given instrumentation to the collection.
   void addInstrumentation(std::unique_ptr<PassInstrumentation> pi);
 
 private:
   std::unique_ptr<detail::PassInstrumentorImpl> impl;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 namespace llvm {
 template <> struct DenseMapInfo<mlir::PassInstrumentation::PipelineParentInfo> {
   using T = mlir::PassInstrumentation::PipelineParentInfo;
   using PairInfo = DenseMapInfo<std::pair<uint64_t, void *>>;
 
   static T getEmptyKey() {
     auto pair = PairInfo::getEmptyKey();
     return {pair.first, reinterpret_cast<mlir::Pass *>(pair.second)};
   }
   static T getTombstoneKey() {
     auto pair = PairInfo::getTombstoneKey();
     return {pair.first, reinterpret_cast<mlir::Pass *>(pair.second)};
   }
   static unsigned getHashValue(T val) {
     return PairInfo::getHashValue({val.parentThreadID, val.parentPass});
   }
   static bool isEqual(T lhs, T rhs) {
     return lhs.parentThreadID == rhs.parentThreadID &&
            lhs.parentPass == rhs.parentPass;
   }
 };
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_PASS_PASSINSTRUMENTATION_H_

mlir/include/mlir/Pass/PassManager.h

 #include "llvm/ADT/iterator.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <functional>
 #include <vector>
 
 namespace llvm {
 class Any;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class AnalysisManager;
 class MLIRContext;
 class Operation;
 class Pass;
 class PassInstrumentation;
 class PassInstrumentor;
 class StringAttr;
 
 namespace detail {
 struct OpPassManagerImpl;
 class OpToOpPassAdaptor;
 class PassCrashReproducerGenerator;
 struct PassExecutionState;
-} // end namespace detail
+} // namespace detail
 
 //===----------------------------------------------------------------------===//
 // OpPassManager
 //===----------------------------------------------------------------------===//
 
 /// This class represents a pass manager that runs passes on a specific
 /// operation type. This class is not constructed directly, but nested within
 /// other OpPassManagers or the top-level PassManager.

 void applyPassManagerCLOptions(PassManager &pm);
 
 /// Apply any values provided to the timing manager options that were registered
 /// with `registerDefaultTimingManagerOptions`. This is a handy helper function
 /// if you do not want to bother creating your own timing manager and passing it
 /// to the pass manager.
 void applyDefaultTimingPassManagerCLOptions(PassManager &pm);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PASS_PASSMANAGER_H

mlir/include/mlir/Pass/PassOptions.h

public:
 
   /// Return the maximum width required when printing the help string.
   size_t getOptionWidth() const;
 
 private:
   /// A list of all of the opaque options.
   std::vector<OptionBase *> options;
 };
-} // end namespace detail
+} // namespace detail
 
 //===----------------------------------------------------------------------===//
 // PassPipelineOptions
 //===----------------------------------------------------------------------===//
 
 /// Subclasses of PassPipelineOptions provide a set of options that can be used
 /// to initialize a pass pipeline. See PassPipelineRegistration for usage
 /// details.
public:
   }
 };
 
 /// A default empty option struct to be used for passes that do not need to take
 /// any options.
 struct EmptyPipelineOptions : public PassPipelineOptions<EmptyPipelineOptions> {
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PASS_PASSOPTIONS_H_
 

mlir/include/mlir/Pass/PassRegistry.h

 #include <functional>
 
 namespace mlir {
 class OpPassManager;
 class Pass;
 
 namespace detail {
 class PassOptions;
-} // end namespace detail
+} // namespace detail
 
 /// A registry function that adds passes to the given pass manager. This should
 /// also parse options and return success() if parsing succeeded.
 /// `errorHandler` is a functor used to emit errors during parsing.
 /// parameter corresponds to the raw location within the pipeline string. This
 /// should always return failure.
 using PassRegistryFunction = std::function<LogicalResult(
     OpPassManager &, StringRef options,
LogicalResult parsePassPipeline(StringRef pipeline, OpPassManager &pm,
                                 raw_ostream &errorStream = llvm::errs());
 
 //===----------------------------------------------------------------------===//
 // PassPipelineCLParser
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct PassPipelineCLParserImpl;
-} // end namespace detail
+} // namespace detail
 
 /// This class implements a command-line parser for MLIR passes. It registers a
 /// cl option with a given argument and description. This parser will register
 /// options for each of the passes and pipelines that have been registered with
 /// the pass registry; Meaning that `-cse` will refer to the CSE pass in MLIR.
 /// It also registers an argument, `pass-pipeline`, that supports parsing a
 /// textual description of a pipeline.
 class PassPipelineCLParser {
public:
   /// Returns true if the given pass registry entry was registered at the
   /// top-level of the parser, i.e. not within an explicit textual pipeline.
   bool contains(const PassRegistryEntry *entry) const;
 
 private:
   std::unique_ptr<detail::PassPipelineCLParserImpl> impl;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_PASS_PASSREGISTRY_H_

mlir/include/mlir/Reducer/PassDetail.h

 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 #define GEN_PASS_CLASSES
 #include "mlir/Reducer/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_REDUCER_PASSDETAIL_H

mlir/include/mlir/Reducer/Passes.h

 std::unique_ptr<Pass> createReductionTreePass();
 
 std::unique_ptr<Pass> createOptReductionPass();
 
 /// Generate the code for registering reducer passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Reducer/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_REDUCER_PASSES_H

mlir/include/mlir/Reducer/ReductionNode.h

 template <>
 class ReductionNode::iterator<SinglePath>
     : public BaseIterator<iterator<SinglePath>> {
   friend BaseIterator<iterator<SinglePath>>;
   using BaseIterator::BaseIterator;
   ArrayRef<ReductionNode *> getNeighbors(ReductionNode *node);
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_REDUCER_REDUCTIONNODE_H

mlir/include/mlir/Reducer/ReductionPatternInterface.h

public:
   /// tensor<?xindex> with a known rank and type, e.g. tensor<1xi32>, or
   /// replacing an operation with a constant.
   virtual void populateReductionPatterns(RewritePatternSet &patterns) const = 0;
 
 protected:
   DialectReductionPatternInterface(Dialect *dialect) : Base(dialect) {}
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_REDUCER_REDUCTIONPATTERNINTERFACE_H

mlir/include/mlir/Reducer/Tester.h

public:
   /// Return whether the file in the given path is interesting.
   Interestingness isInteresting(StringRef testCase) const;
 
 private:
   StringRef testScript;
   ArrayRef<std::string> testScriptArgs;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif

mlir/include/mlir/Rewrite/FrozenRewritePatternSet.h

 //===- FrozenRewritePatternSet.h --------------------------------*- 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_REWRITE_FROZENREWRITEPATTERNSET_H
 #define MLIR_REWRITE_FROZENREWRITEPATTERNSET_H
 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 namespace detail {
 class PDLByteCode;
-} // end namespace detail
+} // namespace detail
 
 /// This class represents a frozen set of patterns that can be processed by a
 /// pattern applicator. This class is designed to enable caching pattern lists
 /// such that they need not be continuously recomputed. Note that all copies of
 /// this class share the same compiled pattern list, allowing for a reduction in
 /// the number of duplicated patterns that need to be created.
 class FrozenRewritePatternSet {
   using NativePatternListT = std::vector<std::unique_ptr<RewritePattern>>;
private:
 
   /// A pointer to the internal pattern list. This uses a shared_ptr to avoid
   /// the need to compile the same pattern list multiple times. For example,
   /// during multi-threaded pass execution, all copies of a pass can share the
   /// same pattern list.
   std::shared_ptr<Impl> impl;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_REWRITE_FROZENREWRITEPATTERNSET_H

mlir/include/mlir/Rewrite/PatternApplicator.h

 
 #include "mlir/Rewrite/FrozenRewritePatternSet.h"
 
 namespace mlir {
 class PatternRewriter;
 
 namespace detail {
 class PDLByteCodeMutableState;
-} // end namespace detail
+} // namespace detail
 
 /// This class manages the application of a group of rewrite patterns, with a
 /// user-provided cost model.
 class PatternApplicator {
 public:
   /// The cost model dynamically assigns a PatternBenefit to a particular
   /// pattern. Users can query contained patterns and pass analysis results to
   /// applyCostModel. Patterns to be discarded should have a benefit of
private:
   DenseMap<OperationName, SmallVector<const RewritePattern *, 2>> patterns;
   /// The set of patterns that may match against any operation type, stable
   /// sorted by benefit.
   SmallVector<const RewritePattern *, 1> anyOpPatterns;
   /// The mutable state used during execution of the PDL bytecode.
   std::unique_ptr<detail::PDLByteCodeMutableState> mutableByteCodeState;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_REWRITE_PATTERNAPPLICATOR_H

mlir/include/mlir/Support/DebugAction.h

static constexpr bool canHandleWith() {
     return llvm::is_invocable<function_ref<void(ParameterTs...)>,
                               CallerParameterTs...>::value;
   }
 
   /// Allow access to `canHandleWith`.
   friend class DebugActionManager;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_SUPPORT_DEBUGACTION_H

mlir/include/mlir/Support/InterfaceSupport.h

void *lookup(TypeID id) const {
     });
     return (it != interfaces.end() && it->first == id) ? it->second : nullptr;
   }
 
   /// A list of interface instances, sorted by TypeID.
   SmallVector<std::pair<TypeID, void *>> interfaces;
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 #endif

mlir/include/mlir/Support/LLVM.h

 
 // Other common classes.
 class APInt;
 class APSInt;
 class APFloat;
 template <typename Fn> class function_ref;
 template <typename IteratorT> class iterator_range;
 class raw_ostream;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 // Casting operators.
 using llvm::cast;
 using llvm::cast_or_null;
 using llvm::dyn_cast;
 using llvm::dyn_cast_or_null;
 using llvm::isa;

mlir/include/mlir/Support/MathExtras.h

 /// Returns the least common multiple of 'a' and 'b'.
 inline int64_t lcm(int64_t a, int64_t b) {
   uint64_t x = std::abs(a);
   uint64_t y = std::abs(b);
   int64_t lcm = (x * y) / llvm::GreatestCommonDivisor64(x, y);
   assert((lcm >= a && lcm >= b) && "LCM overflow");
   return lcm;
 }
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_SUPPORT_MATHEXTRAS_H_

mlir/include/mlir/Support/MlirOptMain.h

 #include "llvm/ADT/StringRef.h"
 
 #include <cstdlib>
 #include <memory>
 
 namespace llvm {
 class raw_ostream;
 class MemoryBuffer;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 class DialectRegistry;
 class PassPipelineCLParser;
 class PassManager;
 
 /// This defines the function type used to setup the pass manager. This can be
 /// used to pass in a callback to setup a default pass pipeline to be applied on

 ///       return mlir::asMainReturnCode(mlir::MlirOptMain(
 ///           argc, argv, /* ... */);
 ///     }
 ///
 inline int asMainReturnCode(LogicalResult r) {
   return r.succeeded() ? EXIT_SUCCESS : EXIT_FAILURE;
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_SUPPORT_MLIROPTMAIN_H

mlir/include/mlir/Support/StorageUniquer.h

private:
   template <typename ImplTy, typename DerivedKey>
   static typename std::enable_if<!llvm::is_detected<detail::has_impltype_hash_t,
                                                     ImplTy, DerivedKey>::value,
                                  ::llvm::hash_code>::type
   getHash(const DerivedKey &derivedKey) {
     return DenseMapInfo<DerivedKey>::getHashValue(derivedKey);
   }
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif

mlir/include/mlir/Support/ThreadLocalCache.h

private:
   /// Owning pointers to all of the values that have been constructed for this
   /// object in the static cache.
   SmallVector<std::shared_ptr<ValueT>, 1> instances;
 
   /// A mutex used when a new thread instance has been added to the cache for
   /// this object.
   llvm::sys::SmartMutex<true> instanceMutex;
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_SUPPORT_THREADLOCALCACHE_H

mlir/include/mlir/Support/TypeID.h

 TypeID TypeID::get() {
   return detail::TypeIDExported::get<T>();
 }
 template <template <typename> class Trait>
 TypeID TypeID::get() {
   return detail::TypeIDExported::get<Trait>();
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 // Declare/define an explicit specialization for TypeID: this forces the
 // compiler to emit a strong definition for a class and controls which
 // translation unit and shared object will actually have it.
 // This can be useful to turn to a link-time failure what would be in other
 // circumstances a hard-to-catch runtime bug when a TypeID is hidden in two
 // different shared libraries and instances of the same class only gets the same
 // TypeID inside a given DSO.
static inline void *getAsVoidPointer(mlir::TypeID info) {
     return const_cast<void *>(info.getAsOpaquePointer());
   }
   static inline mlir::TypeID getFromVoidPointer(void *ptr) {
     return mlir::TypeID::getFromOpaquePointer(ptr);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };
 
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_SUPPORT_TYPEID_H

mlir/include/mlir/TableGen/Argument.h

 
 #include "mlir/TableGen/Attribute.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/PointerUnion.h"
 #include <string>
 
 namespace llvm {
 class StringRef;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // A struct wrapping an op attribute and its name together
 struct NamedAttribute {
   llvm::StringRef name;
   Attribute attr;
struct NamedTypeConstraint {
 
   llvm::StringRef name;
   TypeConstraint constraint;
 };
 
 // Operation argument: either attribute or operand
 using Argument = llvm::PointerUnion<NamedAttribute *, NamedTypeConstraint *>;
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_ARGUMENT_H_

mlir/include/mlir/TableGen/AttrOrTypeDef.h

 //===----------------------------------------------------------------------===//
 
 /// This class represents a wrapper around a tablegen TypeDef record.
 class TypeDef : public AttrOrTypeDef {
 public:
   using AttrOrTypeDef::AttrOrTypeDef;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_ATTRORTYPEDEF_H

mlir/include/mlir/TableGen/Attribute.h

 
 #include "mlir/Support/LLVM.h"
 #include "mlir/TableGen/Constraint.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class DefInit;
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 class Dialect;
 class Type;
 
 // Wrapper class with helper methods for accessing attribute constraints defined
 // in TableGen.
public:
   StringRef getCppNamespace() const;
 
   std::vector<StructFieldAttr> getAllFields() const;
 };
 
 // Name of infer type op interface.
 extern const char *inferTypeOpInterface;
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_ATTRIBUTE_H_

mlir/include/mlir/TableGen/Builder.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class Init;
 class Record;
 class SMLoc;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 /// Wrapper class with helper methods for accessing Builders defined in
 /// TableGen.
 class Builder {
 public:
protected:
   /// The TableGen definition of this builder.
   const llvm::Record *def;
 
 private:
   /// A collection of parameters to the builder.
   SmallVector<Parameter> parameters;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_BUILDER_H_

mlir/include/mlir/TableGen/Class.h

private:
     std::string value;
   };
 
 private:
   /// The list of member initializers.
   SmallVector<MemberInitializer> initializers;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 /// The OR of two method properties should return method properties. Ensure that
 /// this function is visible to `Class`.
 inline constexpr mlir::tblgen::Method::Properties
 operator|(mlir::tblgen::Method::Properties lhs,
           mlir::tblgen::Method::Properties rhs) {
   return mlir::tblgen::Method::Properties(static_cast<unsigned>(lhs) |
                                           static_cast<unsigned>(rhs));

mlir/include/mlir/TableGen/CodeGenHelpers.h

NamespaceEmitter(raw_ostream &os, const Dialect &dialect) : os(os) {
     emitNamespaceStarts(os, dialect.getCppNamespace());
   }
   NamespaceEmitter(raw_ostream &os, StringRef cppNamespace) : os(os) {
     emitNamespaceStarts(os, cppNamespace);
   }
 
   ~NamespaceEmitter() {
     for (StringRef ns : llvm::reverse(namespaces))
-      os << "} // end namespace " << ns << "\n";
+      os << "} // namespace " << ns << "\n";
   }
 
 private:
   void emitNamespaceStarts(raw_ostream &os, StringRef cppNamespace) {
     llvm::SplitString(cppNamespace, namespaces, "::");
     for (StringRef ns : namespaces)
       os << "namespace " << ns << " {\n";
   }

 };
 template <typename OptionalT>
 struct stringifier<Optional<OptionalT>> {
   static std::string apply(Optional<OptionalT> optional) {
     return optional.hasValue() ? stringifier<OptionalT>::apply(*optional)
                                : std::string();
   }
 };
-} // end namespace detail
+} // namespace detail
 
 /// Generically convert a value to a std::string.
 template <typename T> std::string stringify(T &&t) {
   return detail::stringifier<std::remove_reference_t<std::remove_const_t<T>>>::
       apply(std::forward<T>(t));
 }
 
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_CODEGENHELPERS_H

mlir/include/mlir/TableGen/Constraint.h

 
 #include "mlir/Support/LLVM.h"
 #include "mlir/TableGen/Predicate.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class with helper methods for accessing Constraint defined in
 // TableGen.
 class Constraint {
 public:
struct AppliedConstraint {
 
   Constraint constraint;
   // The symbol to replace `$_self` special placeholder in the constraint.
   std::string self;
   // The symbols to replace `$N` positional placeholders in the constraint.
   std::vector<std::string> entities;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_CONSTRAINT_H_

mlir/include/mlir/TableGen/Dialect.h

 #define MLIR_TABLEGEN_DIALECT_H_
 
 #include "mlir/Support/LLVM.h"
 #include <string>
 #include <vector>
 
 namespace llvm {
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 // Wrapper class that contains a MLIR dialect's information defined in TableGen
 // and provides helper methods for accessing them.
 class Dialect {
 public:
   explicit Dialect(const llvm::Record *def);
public:
   // Returns how the accessors should be prefixed in dialect.
   enum class EmitPrefix { Raw = 0, Prefixed = 1, Both = 2 };
   EmitPrefix getEmitAccessorPrefix() const;
 
 private:
   const llvm::Record *def;
   std::vector<StringRef> dependentDialects;
 };
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_DIALECT_H_

mlir/include/mlir/TableGen/Format.h

return FmtObject<ParamTuple>(
           llvm::detail::build_format_adapter(std::forward<Ts>(vals))...));
 }
 
 inline FmtStrVecObject tgfmt(StringRef fmt, const FmtContext *ctx,
                              ArrayRef<std::string> params) {
   return FmtStrVecObject(fmt, ctx, params);
 }
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_FORMAT_H_

mlir/include/mlir/TableGen/GenInfo.h

 #define MLIR_TABLEGEN_GENINFO_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 
 namespace llvm {
 class RecordKeeper;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 
 /// Generator function to invoke.
 using GenFunction = std::function<bool(const llvm::RecordKeeper &recordKeeper,
                                        raw_ostream &os)>;
 
 /// Structure to group information about a generator (argument to invoke via

 /// Usage:
 ///
 ///   // At namespace scope.
 ///   static GenRegistration Print("print", "Print records", [](...){...});
 struct GenRegistration {
   GenRegistration(StringRef arg, StringRef description, GenFunction function);
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_GENINFO_H_

mlir/include/mlir/TableGen/GenNameParser.h

 
 /// Adds command line option for each registered generator.
 struct GenNameParser : public llvm::cl::parser<const GenInfo *> {
   GenNameParser(llvm::cl::Option &opt);
 
   void printOptionInfo(const llvm::cl::Option &O,
                        size_t GlobalWidth) const override;
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_GENNAMEPARSER_H_

mlir/include/mlir/TableGen/Interfaces.h

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 class Init;
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class with helper methods for accessing InterfaceMethod defined
 // in TableGen.
 class InterfaceMethod {
 public:
struct OpInterface : public Interface {
   static bool classof(const Interface *interface);
 };
 // An interface that is registered to a Type.
 struct TypeInterface : public Interface {
   using Interface::Interface;
 
   static bool classof(const Interface *interface);
 };
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_INTERFACES_H_

mlir/include/mlir/TableGen/Operator.h

 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SMLoc.h"
 
 namespace llvm {
 class DefInit;
 class Record;
 class StringInit;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class that contains a MLIR op's information (e.g., operands,
 // attributes) defined in TableGen and provides helper methods for
 // accessing them.
 class Operator {
private:
 
   // The TableGen definition of this op.
   const llvm::Record &def;
 
   // Whether the type of all results are known.
   bool allResultsHaveKnownTypes;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_OPERATOR_H_

mlir/include/mlir/TableGen/Pass.h

 //===- Pass.h - TableGen pass definitions -----------------------*- 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_TABLEGEN_PASS_H_
 #define MLIR_TABLEGEN_PASS_H_
 
 #include "mlir/Support/LLVM.h"
 #include <vector>
 
 namespace llvm {
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 //===----------------------------------------------------------------------===//
 // PassOption
 //===----------------------------------------------------------------------===//
 class PassOption {
 public:

 
 private:
   const llvm::Record *def;
   std::vector<StringRef> dependentDialects;
   std::vector<PassOption> options;
   std::vector<PassStatistic> statistics;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_PASS_H_

mlir/include/mlir/TableGen/Pattern.h

 #include "llvm/ADT/StringSet.h"
 
 #include <unordered_map>
 
 namespace llvm {
 class DagInit;
 class Init;
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // Mapping from TableGen Record to Operator wrapper object.
 //
 // We allocate each wrapper object in heap to make sure the pointer to it is
 // valid throughout the lifetime of this map. This is important because this map
private:
   const llvm::Record &def;
 
   // All operators.
   // TODO: we need a proper context manager, like MLIRContext, for managing the
   // lifetime of shared entities.
   RecordOperatorMap *recordOpMap;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 namespace llvm {
 template <>
 struct DenseMapInfo<mlir::tblgen::DagNode> {
   static mlir::tblgen::DagNode getEmptyKey() {
     return mlir::tblgen::DagNode(
         llvm::DenseMapInfo<llvm::DagInit *>::getEmptyKey());
   }
struct DenseMapInfo<mlir::tblgen::DagLeaf> {
   }
   static unsigned getHashValue(mlir::tblgen::DagLeaf leaf) {
     return llvm::hash_value(leaf.getAsOpaquePointer());
   }
   static bool isEqual(mlir::tblgen::DagLeaf lhs, mlir::tblgen::DagLeaf rhs) {
     return lhs.def == rhs.def;
   }
 };
-} // end namespace llvm
+} // namespace llvm
 
 #endif // MLIR_TABLEGEN_PATTERN_H_

mlir/include/mlir/TableGen/Predicate.h

 #include <string>
 #include <vector>
 
 namespace llvm {
 class Init;
 class ListInit;
 class Record;
 class SMLoc;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // A logical predicate.  This class must closely follow the definition of
 // TableGen class 'Pred'.
 class Pred {
 public:

 // A combined predicate that prepends a prefix and appends a suffix to the
 // predicate string composed from a child predicate.
 class ConcatPred : public CombinedPred {
 public:
   StringRef getPrefix() const;
   StringRef getSuffix() const;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_PREDICATE_H_

mlir/include/mlir/TableGen/Region.h

 struct NamedRegion {
   // Returns true if this region is variadic.
   bool isVariadic() const { return constraint.isVariadic(); }
 
   StringRef name;
   Region constraint;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_REGION_H_

mlir/include/mlir/TableGen/SideEffects.h

public:
   Operator::var_decorator_range getEffects() const;
 
   // Return the name of the base C++ effect.
   StringRef getBaseEffectName() const;
 
   static bool classof(const Trait *t);
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_SIDEEFFECTS_H_

mlir/include/mlir/TableGen/Successor.h

 struct NamedSuccessor {
   // Returns true if this successor is variadic.
   bool isVariadic() const { return constraint.isVariadic(); }
 
   StringRef name;
   Successor constraint;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_SUCCESSOR_H_

mlir/include/mlir/TableGen/Trait.h

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include <vector>
 
 namespace llvm {
 class Init;
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 class Interface;
 
 // Wrapper class with helper methods for accessing Trait constraints defined in
 // TableGen.
public:
   // Whether the declaration of methods for this trait should be emitted.
   bool shouldDeclareMethods() const;
 
   // Returns the methods that should always be declared if this interface is
   // emitting declarations.
   std::vector<StringRef> getAlwaysDeclaredMethods() const;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_TRAIT_H_

mlir/include/mlir/TableGen/Type.h

 
 #include "mlir/Support/LLVM.h"
 #include "mlir/TableGen/Constraint.h"
 #include "mlir/TableGen/Dialect.h"
 
 namespace llvm {
 class DefInit;
 class Record;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 // Wrapper class with helper methods for accessing Type constraints defined in
 // TableGen.
 class TypeConstraint : public Constraint {
 public:
public:
 
   // Returns the description of the type.
   StringRef getDescription() const;
 
   // Returns the dialect for the type if defined.
   Dialect getDialect() const;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TABLEGEN_TYPE_H_

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

 class Attribute;
 class Block;
 class Location;
 
 namespace LLVM {
 
 namespace detail {
 class DebugTranslation;
-} // end namespace detail
+} // namespace detail
 
 class LLVMFuncOp;
 
 /// Implementation class for module translation. Holds a reference to the module
 /// being translated, and the mappings between the original and the translated
 /// functions, basic blocks and values. It is practically easier to hold these
 /// mappings in one class since the conversion of control flow operations
 /// needs to look up block and function mappings.

mlir/include/mlir/Target/SPIRV/Deserialization.h

 
 /// Deserializes the given SPIR-V `binary` module and creates a MLIR ModuleOp
 /// in the given `context`. Returns the ModuleOp on success; otherwise, reports
 /// errors to the error handler registered with `context` and returns a null
 /// module.
 OwningOpRef<spirv::ModuleOp> deserialize(ArrayRef<uint32_t> binary,
                                          MLIRContext *context);
 
-} // end namespace spirv
-} // end namespace mlir
+} // namespace spirv
+} // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_DESERIALIZATION_H

mlir/include/mlir/Target/SPIRV/SPIRVBinaryUtils.h

void appendModuleHeader(SmallVectorImpl<uint32_t> &header,
                         spirv::Version version, uint32_t idBound);
 
 /// Returns the word-count-prefixed opcode for an SPIR-V instruction.
 uint32_t getPrefixedOpcode(uint32_t wordCount, spirv::Opcode opcode);
 
 /// Encodes an SPIR-V `literal` string into the given `binary` vector.
 LogicalResult encodeStringLiteralInto(SmallVectorImpl<uint32_t> &binary,
                                       StringRef literal);
-} // end namespace spirv
-} // end namespace mlir
+} // namespace spirv
+} // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_BINARY_UTILS_H_

mlir/include/mlir/Target/SPIRV/Serialization.h

 class ModuleOp;
 
 /// Serializes the given SPIR-V `module` and writes to `binary`. On failure,
 /// reports errors to the error handler registered with the MLIR context for
 /// `module`.
 LogicalResult serialize(ModuleOp module, SmallVectorImpl<uint32_t> &binary,
                         bool emitDebugInfo = false);
 
-} // end namespace spirv
-} // end namespace mlir
+} // namespace spirv
+} // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_SERIALIZATION_H

mlir/include/mlir/Tools/mlir-lsp-server/MlirLspServerMain.h

 struct LogicalResult;
 
 /// Implementation for tools like `mlir-lsp-server`.
 /// - registry should contain all the dialects that can be parsed in source IR
 /// passed to the server.
 LogicalResult MlirLspServerMain(int argc, char **argv,
                                 DialectRegistry &registry);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRLSPSERVER_MLIRLSPSERVERMAIN_H

mlir/include/mlir/Tools/mlir-reduce/MlirReduceMain.h

 #include "mlir/Support/LogicalResult.h"
 
 namespace mlir {
 
 class MLIRContext;
 
 LogicalResult mlirReduceMain(int argc, char **argv, MLIRContext &context);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRREDUCE_MLIRREDUCEMAIN_H

mlir/include/mlir/Transforms/BufferUtils.h

 
 private:
   ModuleOp moduleOp;
   unsigned alignment;
   // This could use memref::GlobalOp key but we avoid introducing a new
   // dependence to the memref dialect for this.
   DenseMap<Attribute, Operation *> globals;
 };
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_BUFFERUTILS_H

mlir/include/mlir/Transforms/DialectConversion.h

void populateFuncOpTypeConversionPattern(RewritePatternSet &patterns,
                                          TypeConverter &converter);
 
 //===----------------------------------------------------------------------===//
 // Conversion PatternRewriter
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct ConversionPatternRewriterImpl;
-} // end namespace detail
+} // namespace detail
 
 /// This class implements a pattern rewriter for use with ConversionPatterns. It
 /// extends the base PatternRewriter and provides special conversion specific
 /// hooks.
 class ConversionPatternRewriter final : public PatternRewriter {
 public:
   explicit ConversionPatternRewriter(MLIRContext *ctx);
   ~ConversionPatternRewriter() override;
LogicalResult applyAnalysisConversion(
     const FrozenRewritePatternSet &patterns,
     DenseSet<Operation *> &convertedOps,
     function_ref<void(Diagnostic &)> notifyCallback = nullptr);
 LogicalResult applyAnalysisConversion(
     Operation *op, ConversionTarget &target,
     const FrozenRewritePatternSet &patterns,
     DenseSet<Operation *> &convertedOps,
     function_ref<void(Diagnostic &)> notifyCallback = nullptr);
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_DIALECTCONVERSION_H_

mlir/include/mlir/Transforms/FoldUtils.h

private:
   /// This map tracks all of the dialects that an operation is referenced by;
   /// given that many dialects may generate the same constant.
   DenseMap<Operation *, SmallVector<Dialect *, 2>> referencedDialects;
 
   /// A collection of dialect folder interfaces.
   DialectInterfaceCollection<DialectFoldInterface> interfaces;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_FOLDUTILS_H

mlir/include/mlir/Transforms/GreedyPatternRewriteDriver.h

 /// (i.e., regardless of `strict`). Note that ops in `ops` could be erased as a
 /// result of folding, becoming dead, or via pattern rewrites. If more far
 /// reaching simplification is desired, applyPatternsAndFoldGreedily should be
 /// used. Returns true if at all any IR was rewritten.
 bool applyOpPatternsAndFold(ArrayRef<Operation *> ops,
                             const FrozenRewritePatternSet &patterns,
                             bool strict);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_GREEDYPATTERNREWRITEDRIVER_H_

mlir/include/mlir/Transforms/InliningUtils.h

 /// function returns failure if inlining is not possible, success otherwise. On
 /// failure, no changes are made to the module. 'shouldCloneInlinedRegion'
 /// corresponds to whether the source region should be cloned into the 'call' or
 /// spliced directly.
 LogicalResult inlineCall(InlinerInterface &interface, CallOpInterface call,
                          CallableOpInterface callable, Region *src,
                          bool shouldCloneInlinedRegion = true);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_INLINING_UTILS_H

mlir/include/mlir/Transforms/LocationSnapshot.h

 /// name, and then fused with the existing locations. Otherwise, the existing
 /// locations are replaced.
 std::unique_ptr<Pass> createLocationSnapshotPass(OpPrintingFlags flags,
                                                  StringRef fileName = "",
                                                  StringRef tag = "");
 /// Overload utilizing pass options for initialization.
 std::unique_ptr<Pass> createLocationSnapshotPass();
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_LOCATIONSNAPSHOT_H

mlir/include/mlir/Transforms/LoopFusionUtils.h

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);
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_LOOP_FUSION_UTILS_H

mlir/include/mlir/Transforms/LoopUtils.h

 struct MemRefRegion;
 class OpBuilder;
 class Value;
 class ValueRange;
 
 namespace scf {
 class ForOp;
 class ParallelOp;
-} // end namespace scf
+} // namespace scf
 
 /// 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,

 ///
 LogicalResult
 separateFullTiles(MutableArrayRef<AffineForOp> nest,
                   SmallVectorImpl<AffineForOp> *fullTileNest = nullptr);
 
 /// Move loop invariant code out of `looplike`.
 LogicalResult moveLoopInvariantCode(LoopLikeOpInterface looplike);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_LOOP_UTILS_H

mlir/include/mlir/Transforms/Passes.h

 //===----------------------------------------------------------------------===//
 // Registration
 //===----------------------------------------------------------------------===//
 
 /// Generate the code for registering passes.
 #define GEN_PASS_REGISTRATION
 #include "mlir/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_PASSES_H

mlir/include/mlir/Transforms/Utils.h

 
 class AffineApplyOp;
 class AffineForOp;
 class Location;
 class OpBuilder;
 
 namespace memref {
 class AllocOp;
-} // end namespace memref
+} // namespace memref
 
 /// Replaces all "dereferencing" uses of `oldMemRef` with `newMemRef` while
 /// optionally remapping the old memref's indices using the supplied affine map,
 /// `indexRemap`. The new memref could be of a different shape or rank.
 /// `extraIndices` provides any additional access indices to be added to the
 /// start.
 ///
 /// `indexRemap` remaps indices of the old memref access to a new set of indices

 /// In the following cases, `sliceOps` remains empty:
 ///   1. If none of opInst's operands were the result of an affine.apply
 ///      (i.e., there was no affine computation slice to create).
 ///   2. If all the affine.apply op's supplying operands to this opInst did not
 ///      have any uses other than those in this opInst.
 void createAffineComputationSlice(Operation *opInst,
                                   SmallVectorImpl<AffineApplyOp> *sliceOps);
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_UTILS_H

mlir/include/mlir/Transforms/ViewOpGraph.h

 
 namespace mlir {
 class Pass;
 
 /// Creates a pass to print op graphs.
 std::unique_ptr<Pass>
 createPrintOpGraphPass(raw_ostream &os = llvm::errs());
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_TRANSFORMS_VIEWOPGRAPH_H_

mlir/lib/Analysis/AffineStructures.cpp

private:
   void addLocalFloorDivId(ArrayRef<int64_t> dividend, int64_t divisor,
                           AffineExpr localExpr) override {
     SimpleAffineExprFlattener::addLocalFloorDivId(dividend, divisor, localExpr);
     // Update localVarCst.
     localVarCst.addLocalFloorDiv(dividend, divisor);
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 // Flattens the expressions in map. Returns failure if 'expr' was unable to be
 // flattened (i.e., semi-affine expressions not handled yet).
 static LogicalResult
 getFlattenedAffineExprs(ArrayRef<AffineExpr> exprs, unsigned numDims,
                         unsigned numSymbols,
                         std::vector<SmallVector<int64_t, 8>> *flattenedExprs,
                         FlatAffineConstraints *localVarCst) {

mlir/lib/Analysis/DataFlowAnalysis.cpp

private:
   /// A map between a call operation and the resolved symbol callable. This
   /// avoids re-resolving symbol references during propagation. Value based
   /// callables are trivial to resolve, so they can be done in-place.
   DenseMap<Operation *, Operation *> callToSymbolCallable;
 
   /// A symbol table used for O(1) symbol lookups during simplification.
   SymbolTableCollection symbolTable;
 };
-} // end anonymous namespace
+} // namespace
 
 ForwardDataFlowSolver::ForwardDataFlowSolver(
     ForwardDataFlowAnalysisBase &analysis, Operation *op)
     : analysis(analysis) {
   /// Initialize the solver with the regions within this operation.
   for (Region &region : op->getRegions()) {
     // Mark the entry block as executable. The values passed to these regions
     // are also invisible, so mark any arguments as reaching the pessimistic

mlir/lib/Analysis/NestedMatcher.cpp

NestedPattern For(FilterFunctionType filter, ArrayRef<NestedPattern> nested) {
   return NestedPattern(
       nested, [=](Operation &op) { return isAffineForOp(op) && filter(op); });
 }
 
 bool isLoadOrStore(Operation &op) {
   return isa<AffineLoadOp, AffineStoreOp>(op);
 }
 
-} // end namespace matcher
-} // end namespace mlir
+} // namespace matcher
+} // namespace mlir

mlir/lib/Analysis/Presburger/Simplex.cpp

 bool signMatchesDirection(int64_t elem, Direction direction) {
   assert(elem != 0 && "elem should not be 0");
   return direction == Direction::Up ? elem > 0 : elem < 0;
 }
 
 Direction flippedDirection(Direction direction) {
   return direction == Direction::Up ? Direction::Down : Simplex::Direction::Up;
 }
-} // anonymous namespace
+} // namespace
 
 /// Find a pivot to change the sample value of the row in the specified
 /// direction. The returned pivot row will involve `row` if and only if the
 /// unknown is unbounded in the specified direction.
 ///
 /// To increase (resp. decrease) the value of a row, we need to find a live
 /// column with a non-zero coefficient. If the coefficient is positive, we need
 /// to increase (decrease) the value of the column, and if the coefficient is

mlir/lib/Bindings/Python/ExecutionEngineModule.cpp

 private:
   MlirExecutionEngine executionEngine;
   // We support Python ctypes closures as callbacks. Keep a list of the objects
   // so that they don't get garbage collected. (The ExecutionEngine itself
   // just holds raw pointers with no lifetime semantics).
   std::vector<py::object> referencedObjects;
 };
 
-} // anonymous namespace
+} // namespace
 
 /// Create the `mlir.execution_engine` module here.
 PYBIND11_MODULE(_mlirExecutionEngine, m) {
   m.doc() = "MLIR Execution Engine";
 
   //----------------------------------------------------------------------------
   // Mapping of the top-level PassManager
   //----------------------------------------------------------------------------

mlir/lib/Bindings/Python/IRAffine.cpp

public:
   PyAffineMapExprList slice(intptr_t startIndex, intptr_t length,
                             intptr_t step) {
     return PyAffineMapExprList(affineMap, startIndex, length, step);
   }
 
 private:
   PyAffineMap affineMap;
 };
-} // end namespace
+} // namespace
 
 bool PyAffineMap::operator==(const PyAffineMap &other) {
   return mlirAffineMapEqual(affineMap, other.affineMap);
 }
 
 py::object PyAffineMap::getCapsule() {
   return py::reinterpret_steal<py::object>(mlirPythonAffineMapToCapsule(*this));
 }

mlir/lib/Bindings/Python/IRCore.cpp

py::class_<PyOpAttributeMap>(m, "OpAttributeMap", py::module_local())
         .def("__setitem__", &PyOpAttributeMap::dunderSetItem)
         .def("__delitem__", &PyOpAttributeMap::dunderDelItem);
   }
 
 private:
   PyOperationRef operation;
 };
 
-} // end namespace
+} // namespace
 
 //------------------------------------------------------------------------------
 // Populates the core exports of the 'ir' submodule.
 //------------------------------------------------------------------------------
 
 void mlir::python::populateIRCore(py::module &m) {
   //----------------------------------------------------------------------------
   // Mapping of MlirContext.

mlir/lib/Bindings/Python/Pass.cpp

if (mlirPassManagerIsNull(rawPm))
       throw py::error_already_set();
     return py::cast(PyPassManager(rawPm), py::return_value_policy::move);
   }
 
 private:
   MlirPassManager passManager;
 };
 
-} // anonymous namespace
+} // namespace
 
 /// Create the `mlir.passmanager` here.
 void mlir::python::populatePassManagerSubmodule(py::module &m) {
   //----------------------------------------------------------------------------
   // Mapping of the top-level PassManager
   //----------------------------------------------------------------------------
   py::class_<PyPassManager>(m, "PassManager", py::module_local())
       .def(py::init<>([](DefaultingPyMlirContext context) {

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

if (!maybeExpandedMap)
       return failure();
 
     rewriter.replaceOpWithNewOp<vector::StoreOp>(
         op, op.getValueToStore(), op.getMemRef(), *maybeExpandedMap);
     return success();
   }
 };
 
-} // end namespace
+} // namespace
 
 void mlir::populateAffineToStdConversionPatterns(RewritePatternSet &patterns) {
   // clang-format off
   patterns.add<
       AffineApplyLowering,
       AffineDmaStartLowering,
       AffineDmaWaitLowering,
       AffineLoadLowering,

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 struct CmpFOpLowering : public ConvertOpToLLVMPattern<arith::CmpFOp> {
   using ConvertOpToLLVMPattern<arith::CmpFOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ConstantOpLowering
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 ConstantOpLowering::matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
                                     ConversionPatternRewriter &rewriter) const {
void runOnFunction() override {
     mlir::arith::populateArithmeticToLLVMConversionPatterns(converter,
                                                             patterns);
 
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern Population
 //===----------------------------------------------------------------------===//
 
 void mlir::arith::populateArithmeticToLLVMConversionPatterns(
     LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   // clang-format off

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

 public:
   using OpConversionPattern<arith::CmpFOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Conversion Helpers
 //===----------------------------------------------------------------------===//
 
 /// Converts the given `srcAttr` into a boolean attribute if it holds an
 /// integral value. Returns null attribute if conversion fails.
 static BoolAttr convertBoolAttr(Attribute srcAttr, Builder builder) {
void runOnFunction() override {
     RewritePatternSet patterns(&getContext());
     mlir::arith::populateArithmeticToSPIRVPatterns(typeConverter, patterns);
 
     if (failed(applyPartialConversion(getOperation(), *target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::arith::createConvertArithmeticToSPIRVPass() {
   return std::make_unique<ConvertArithmeticToSPIRVPass>();
 }

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

void runOnOperation() override {
     populateGpuWMMAToNVVMConversionPatterns(converter, llvmPatterns);
     LLVMConversionTarget target(getContext());
     configureGpuToNVVMConversionLegality(target);
     if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
       signalPassFailure();
   }
 };
 
-} // anonymous namespace
+} // namespace
 
 void mlir::configureGpuToNVVMConversionLegality(ConversionTarget &target) {
   target.addIllegalOp<FuncOp>();
   target.addLegalDialect<::mlir::LLVM::LLVMDialect>();
   target.addLegalDialect<::mlir::NVVM::NVVMDialect>();
   target.addIllegalDialect<gpu::GPUDialect>();
   target.addIllegalOp<LLVM::CosOp, LLVM::ExpOp, LLVM::Exp2Op, LLVM::FAbsOp,
                       LLVM::FCeilOp, LLVM::FFloorOp, LLVM::LogOp, LLVM::Log10Op,

mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp

for (size_t i = 0, e = destType.getBody().size(); i < e; ++i) {
       matrixStruct = rewriter.create<LLVM::InsertValueOp>(
           loc, matrixStruct, element, rewriter.getI32ArrayAttr(i));
     }
     rewriter.replaceOp(subgroupMmaElementwiseOp, matrixStruct);
     return success();
   }
 };
 
-} // anonymous namespace
+} // namespace
 
 namespace mlir {
 
 /// Return the LLVMStructureType corresponding to the MMAMatrixType `type`.
 LLVM::LLVMStructType convertMMAToLLVMType(gpu::MMAMatrixType type) {
   NVVM::MMAFrag frag = convertOperand(type.getOperand());
   NVVM::MMATypes eltType = getElementType(type);
   std::pair<Type, unsigned> typeInfo =

mlir/lib/Conversion/GPUToROCDL/LowerGpuOpsToROCDLOps.cpp

void runOnOperation() override {
     populateGpuToROCDLConversionPatterns(converter, llvmPatterns);
     LLVMConversionTarget target(getContext());
     configureGpuToROCDLConversionLegality(target);
     if (failed(applyPartialConversion(m, target, std::move(llvmPatterns))))
       signalPassFailure();
   }
 };
 
-} // anonymous namespace
+} // namespace
 
 void mlir::configureGpuToROCDLConversionLegality(ConversionTarget &target) {
   target.addIllegalOp<FuncOp>();
   target.addLegalDialect<::mlir::LLVM::LLVMDialect>();
   target.addLegalDialect<ROCDL::ROCDLDialect>();
   target.addIllegalDialect<gpu::GPUDialect>();
   target.addIllegalOp<LLVM::CosOp, LLVM::ExpOp, LLVM::Exp2Op, LLVM::FAbsOp,
                       LLVM::FCeilOp, LLVM::FFloorOp, LLVM::LogOp, LLVM::Log10Op,

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

LogicalResult declareVulkanLaunchFunc(Location loc,
                                         gpu::LaunchFuncOp launchOp);
 
 private:
   /// The number of vulkan launch configuration operands, placed at the leading
   /// positions of the operand list.
   static constexpr unsigned kVulkanLaunchNumConfigOperands = 3;
 };
 
-} // anonymous namespace
+} // namespace
 
 void ConvertGpuLaunchFuncToVulkanLaunchFunc::runOnOperation() {
   bool done = false;
   getOperation().walk([this, &done](gpu::LaunchFuncOp op) {
     if (done) {
       op.emitError("should only contain one 'gpu::LaunchFuncOp' op");
       return signalPassFailure();
     }

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

private:
 
   // TODO: Use an associative array to support multiple vulkan launch calls.
   std::pair<StringAttr, StringAttr> spirvAttributes;
   /// The number of vulkan launch configuration operands, placed at the leading
   /// positions of the operand list.
   static constexpr unsigned kVulkanLaunchNumConfigOperands = 3;
 };
 
-} // anonymous namespace
+} // namespace
 
 void VulkanLaunchFuncToVulkanCallsPass::runOnOperation() {
   initializeCachedTypes();
 
   // Collect SPIR-V attributes such as `spirv_blob` and
   // `spirv_entry_point_name`.
   getOperation().walk([this](LLVM::CallOp op) {
     if (isVulkanLaunchCallOp(op))

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

private:
   /// A mapping between values defined in a pattern match, and the corresponding
   /// positional value.
   DenseMap<Value, Position *> valueToPosition;
 
   /// The set of operation values whose whose location will be used for newly
   /// generated operations.
   SetVector<Value> locOps;
 };
-} // end anonymous namespace
+} // namespace
 
 PatternLowering::PatternLowering(FuncOp matcherFunc, ModuleOp rewriterModule)
     : builder(matcherFunc.getContext()), matcherFunc(matcherFunc),
       rewriterModule(rewriterModule), rewriterSymbolTable(rewriterModule) {}
 
 void PatternLowering::lower(ModuleOp module) {
   PredicateUniquer predicateUniquer;
   PredicateBuilder predicateBuilder(predicateUniquer, module.getContext());

mlir/lib/Conversion/PDLToPDLInterp/Predicate.h

enum Kind : unsigned {
   // Answers.
   AttributeAnswer,
   FalseAnswer,
   OperationNameAnswer,
   TrueAnswer,
   TypeAnswer,
   UnsignedAnswer,
 };
-} // end namespace Predicates
+} // namespace Predicates
 
 /// Base class for all predicates, used to allow efficient pointer comparison.
 template <typename ConcreteT, typename BaseT, typename Key,
           Predicates::Kind Kind>
 class PredicateBase : public BaseT {
 public:
   using KeyTy = Key;
   using Base = PredicateBase<ConcreteT, BaseT, Key, Kind>;

 private:
   /// The uniquer used when allocating predicate nodes.
   PredicateUniquer &uniquer;
 
   /// The current MLIR context.
   MLIRContext *ctx;
 };
 
-} // end namespace pdl_to_pdl_interp
-} // end namespace mlir
+} // namespace pdl_to_pdl_interp
+} // namespace mlir
 
 #endif // MLIR_CONVERSION_PDLTOPDLINTERP_PREDICATE_H_

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.h

struct SwitchNode : public MatcherNode {
   }
 
 private:
   /// Switch predicate "answers" select the child. Answers that are not found
   /// default to the failure node.
   ChildMapT children;
 };
 
-} // end namespace pdl_to_pdl_interp
-} // end namespace mlir
+} // namespace pdl_to_pdl_interp
+} // namespace mlir
 
 #endif // MLIR_CONVERSION_PDLTOPDLINTERP_PREDICATETREE_H_

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.cpp

 struct OrderedPredicateList {
   OrderedPredicateList(pdl::PatternOp pattern, Value root)
       : pattern(pattern), root(root) {}
 
   pdl::PatternOp pattern;
   Value root;
   DenseSet<OrderedPredicate *> predicates;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Returns true if the given matcher refers to the same predicate as the given
 /// ordered predicate. This means that the position and questions of the two
 /// match.
 static bool isSamePredicate(MatcherNode *node, OrderedPredicate *predicate) {
   return node->getPosition() == predicate->position &&
          node->getQuestion() == predicate->question;
 }

mlir/lib/Conversion/PDLToPDLInterp/RootOrdering.h

private:
   /// The computed parent mapping. This is the unique predecessor for each node
   /// in the optimal branching. The keys of this map correspond to the keys of
   /// the outer map of the input graph, and each value is one of the keys of
   /// the inner map for this node. Also used as an intermediate (possibly
   /// cyclical) result in the optimal branching algorithm.
   DenseMap<Value, Value> parents;
 };
 
-} // end namespace pdl_to_pdl_interp
-} // end namespace mlir
+} // namespace pdl_to_pdl_interp
+} // namespace mlir
 
 #endif // MLIR_CONVERSION_PDLTOPDLINTERP_ROOTORDERING_H_

mlir/lib/Conversion/PassDetail.h

 class StandardOpsDialect;
 
 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
 namespace acc {
 class OpenACCDialect;
-} // end namespace acc
+} // namespace acc
 
 namespace arith {
 class ArithmeticDialect;
-} // end namespace arith
+} // namespace arith
 
 namespace complex {
 class ComplexDialect;
-} // end namespace complex
+} // namespace complex
 
 namespace gpu {
 class GPUDialect;
 class GPUModuleOp;
-} // end namespace gpu
+} // namespace gpu
 
 namespace LLVM {
 class LLVMDialect;
-} // end namespace LLVM
+} // namespace LLVM
 
 namespace NVVM {
 class NVVMDialect;
-} // end namespace NVVM
+} // namespace NVVM
 
 namespace math {
 class MathDialect;
-} // end namespace math
+} // namespace math
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 namespace omp {
 class OpenMPDialect;
-} // end namespace omp
+} // namespace omp
 
 namespace pdl_interp {
 class PDLInterpDialect;
-} // end namespace pdl_interp
+} // namespace pdl_interp
 
 namespace ROCDL {
 class ROCDLDialect;
-} // end namespace ROCDL
+} // namespace ROCDL
 
 namespace scf {
 class SCFDialect;
-} // end namespace scf
+} // namespace scf
 
 namespace spirv {
 class SPIRVDialect;
-} // end namespace spirv
+} // namespace spirv
 
 namespace tensor {
 class TensorDialect;
-} // end namespace tensor
+} // namespace tensor
 
 namespace tosa {
 class TosaDialect;
-} // end namespace tosa
+} // namespace tosa
 
 namespace vector {
 class VectorDialect;
-} // end namespace vector
+} // namespace vector
 
 namespace arm_neon {
 class ArmNeonDialect;
-} // end namespace arm_neon
+} // namespace arm_neon
 
 #define GEN_PASS_CLASSES
 #include "mlir/Conversion/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // CONVERSION_PASSDETAIL_H_

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

 struct SCFToOpenMPPass : public ConvertSCFToOpenMPBase<SCFToOpenMPPass> {
   /// Pass entry point.
   void runOnOperation() override {
     if (failed(applyPatterns(getOperation())))
       signalPassFailure();
   }
 };
 
-} // end namespace
+} // namespace
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertSCFToOpenMPPass() {
   return std::make_unique<SCFToOpenMPPass>();
 }

mlir/lib/Conversion/SPIRVCommon/Pattern.h

if (SPIRVOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&
           "bitwidth emulation is not implemented yet on unsigned op");
     }
     rewriter.template replaceOpWithNewOp<SPIRVOp>(op, dstType,
                                                   adaptor.getOperands());
     return success();
   }
 };
 
-} // end namespace spirv
-} // end namespace mlir
+} // namespace spirv
+} // namespace mlir
 
 #endif // MLIR_CONVERSION_SPIRVCOMMON_PATTERN_H

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

void runOnOperation() override {
     LLVMConversionTarget target(getContext());
     if (failed(applyPartialConversion(m, target, std::move(patterns))))
       signalPassFailure();
 
     m->setAttr(LLVM::LLVMDialect::getDataLayoutAttrName(),
                StringAttr::get(m.getContext(), this->dataLayout));
   }
 };
-} // end namespace
+} // namespace
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createLowerToLLVMPass() {
   return std::make_unique<LLVMLoweringPass>();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createLowerToLLVMPass(const LowerToLLVMOptions &options) {
   auto allocLowering = options.allocLowering;

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

matchAndRewrite(ConcreteOp xferOp, typename ConcreteOp::Adaptor adaptor,
     Value int32Zero = rewriter.create<LLVM::ConstantOp>(
         loc, toLLVMTy(i32Ty),
         rewriter.getIntegerAttr(rewriter.getIntegerType(32), 0));
     return replaceTransferOpWithMubuf(
         rewriter, adaptor.getOperands(), *this->getTypeConverter(), loc, xferOp,
         vecTy, dwordConfig, int32Zero, int32Zero, int1False, int1False);
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void mlir::populateVectorToROCDLConversionPatterns(
     LLVMTypeConverter &converter, RewritePatternSet &patterns) {
   patterns.add<VectorTransferConversion<TransferReadOp>,
                VectorTransferConversion<TransferWriteOp>>(converter);
 }
 
 namespace {

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

bool isLegalToInline(Operation *op, Region *region, bool wouldBeCloned,
     Operation *parentOp = region->getParentOp();
     return parentOp->hasTrait<OpTrait::AffineScope>() ||
            isa<AffineForOp, AffineParallelOp, AffineIfOp>(parentOp);
   }
 
   /// Affine regions should be analyzed recursively.
   bool shouldAnalyzeRecursively(Operation *op) const final { return true; }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // AffineDialect
 //===----------------------------------------------------------------------===//
 
 void AffineDialect::initialize() {
   addOperations<AffineDmaStartOp, AffineDmaWaitOp,
 #define GET_OP_LIST

 
 // Generic version for ops that don't have extra operands.
 template <typename AffineOpTy>
 void SimplifyAffineOp<AffineOpTy>::replaceAffineOp(
     PatternRewriter &rewriter, AffineOpTy op, AffineMap map,
     ArrayRef<Value> mapOperands) const {
   rewriter.replaceOpWithNewOp<AffineOpTy>(op, map, mapOperands);
 }
-} // end anonymous namespace.
+} // namespace
 
 void AffineApplyOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                 MLIRContext *context) {
   results.add<SimplifyAffineOp<AffineApplyOp>>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Common canonicalization pattern support logic
LogicalResult matchAndRewrite(AffineForOp forOp,
     // Check that the body only contains a yield.
     if (!llvm::hasSingleElement(*forOp.getBody()))
       return failure();
     // The initial values of the iteration arguments would be the op's results.
     rewriter.replaceOp(forOp, forOp.getIterOperands());
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void AffineForOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                               MLIRContext *context) {
   results.add<AffineForEmptyLoopFolder>(context);
 }
 
 /// Returns true if the affine.for has zero iterations in trivial cases.
 static bool hasTrivialZeroTripCount(AffineForOp op) {
LogicalResult matchAndRewrite(AffineIfOp op,
     // implicitly.
     rewriter.replaceOp(op, blockToMoveTerminator->getOperands());
     // Erase the "blockToMoveTerminator" operation since it is now in the parent
     // operation block, which already has its own terminator.
     rewriter.eraseOp(blockToMoveTerminator);
     return success();
   }
 };
-} // end anonymous namespace.
+} // namespace
 
 static LogicalResult verify(AffineIfOp op) {
   // Verify that we have a condition attribute.
   auto conditionAttr =
       op->getAttrOfType<IntegerSetAttr>(op.getConditionAttrName());
   if (!conditionAttr)
     return op.emitOpError(
         "requires an integer set attribute named 'condition'");
 

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

struct AffineDataCopyGeneration
 
   void runOnFunction() override;
   LogicalResult runOnBlock(Block *block, DenseSet<Operation *> &copyNests);
 
   // Constant zero index to avoid too many duplicates.
   Value zeroIndex = nullptr;
 };
 
-} // end anonymous namespace
+} // 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<FuncOp>> mlir::createAffineDataCopyGenerationPass(
     unsigned slowMemorySpace, unsigned fastMemorySpace, unsigned tagMemorySpace,
     int minDmaTransferSize, uint64_t fastMemCapacityBytes) {

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

 /// 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 AffineLoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
   void runOnFunction() override;
   void runOnAffineForOp(AffineForOp forOp);
 };
-} // end anonymous namespace
+} // namespace
 
 static bool
 checkInvarianceOfNestedIfOps(Operation *op, 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);

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

void loadCSE(AffineReadOpInterface loadOp,
                DominanceInfo &domInfo);
 
   void findUnusedStore(AffineWriteOpInterface storeOp,
                        SmallVectorImpl<Operation *> &storeOpsToErase,
                        SmallPtrSetImpl<Value> &memrefsToErase,
                        PostDominanceInfo &postDominanceInfo);
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Creates a pass to perform optimizations relying on memref dataflow such as
 /// store to load forwarding, elimination of dead stores, and dead allocs.
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createAffineScalarReplacementPass() {
   return std::make_unique<AffineScalarReplacement>();
 }
 

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

struct LoopTiling : public AffineLoopTilingBase<LoopTiling> {
 
   // 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;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Creates a pass to perform loop tiling on all suitable loop nests of a
 /// Function.
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLoopTilingPass(uint64_t cacheSizeBytes) {
   return std::make_unique<LoopTiling>(cacheSizeBytes);
 }
 std::unique_ptr<OperationPass<FuncOp>> mlir::createLoopTilingPass() {

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

explicit LoopUnroll(
     this->unrollFull = unrollFull;
   }
 
   void runOnFunction() override;
 
   /// Unroll this for op. Returns failure if nothing was done.
   LogicalResult runOnAffineForOp(AffineForOp forOp);
 };
-} // end anonymous namespace
+} // namespace
 
 /// Returns true if no other affine.for ops are nested within.
 static bool isInnermostAffineForOp(AffineForOp forOp) {
   // Only for the innermost affine.for op's.
   bool isInnermost = true;
   forOp.walk([&](AffineForOp thisForOp) {
     // Since this is a post order walk, we are able to conclude here.
     isInnermost = (thisForOp == forOp);

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

 struct LoopUnrollAndJam : public AffineLoopUnrollAndJamBase<LoopUnrollAndJam> {
   explicit LoopUnrollAndJam(Optional<unsigned> unrollJamFactor = None) {
     if (unrollJamFactor)
       this->unrollJamFactor = *unrollJamFactor;
   }
 
   void runOnFunction() override;
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLoopUnrollAndJamPass(int unrollJamFactor) {
   return std::make_unique<LoopUnrollAndJam>(
       unrollJamFactor == -1 ? None : Optional<unsigned>(unrollJamFactor));
 }
 
 void LoopUnrollAndJam::runOnFunction() {
   // 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 = getFunction().front();
   if (auto forOp = dyn_cast<AffineForOp>(entryBlock.front()))
     (void)loopUnrollJamByFactor(forOp, unrollJamFactor);
 }

mlir/lib/Dialect/Affine/Transforms/PassDetail.h

 
 namespace mlir {
 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
 namespace linalg {
 class LinalgDialect;
-} // end namespace linalg
+} // namespace linalg
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 namespace vector {
 class VectorDialect;
-} // end namespace vector
+} // namespace vector
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Affine/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_AFFINE_TRANSFORMS_PASSDETAIL_H_

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

AffineMap simplify(AffineMap map) {
     MutableAffineMap mMap(map);
     mMap.simplify();
     return mMap.getAffineMap();
   }
 
   DenseMap<Attribute, Attribute> simplifiedAttributes;
 };
 
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createSimplifyAffineStructuresPass() {
   return std::make_unique<SimplifyAffineStructures>();
 }
 
 void SimplifyAffineStructures::runOnFunction() {
   auto func = getFunction();

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

 /// Base state for the vectorize pass.
 /// Command line arguments are preempted by non-empty pass arguments.
 struct Vectorize : public AffineVectorizeBase<Vectorize> {
   Vectorize() = default;
   Vectorize(ArrayRef<int64_t> virtualVectorSize);
   void runOnFunction() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 Vectorize::Vectorize(ArrayRef<int64_t> virtualVectorSize) {
   vectorSizes = virtualVectorSize;
 }
 
 static void vectorizeLoopIfProfitable(Operation *loop, unsigned depthInPattern,
                                       unsigned patternDepth,
                                       VectorizationStrategy *strategy) {

 
 private:
   /// Internal implementation to map input scalar values to new vector or scalar
   /// values.
   void registerValueVectorReplacementImpl(Value replaced, Value replacement);
   void registerValueScalarReplacementImpl(Value replaced, Value replacement);
 };
 
-} // end namespace
+} // namespace
 
 /// Registers the vector replacement of a scalar operation and its result
 /// values. Both operations must have the same number of results.
 ///
 /// This utility is used to register the replacement for the vast majority of
 /// the vectorized operations.
 ///
 /// Example:

mlir/lib/Dialect/Arithmetic/IR/ArithmeticDialect.cpp

struct ArithmeticInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   /// All arithmetic dialect ops can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void arith::ArithmeticDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.cpp.inc"
       >();
   addInterfaces<ArithmeticInlinerInterface>();
 }
 
 /// Materialize an integer or floating point constant.
 Operation *arith::ArithmeticDialect::materializeConstant(OpBuilder &builder,
                                                          Attribute value,
                                                          Type type,
                                                          Location loc) {
   return builder.create<arith::ConstantOp>(loc, value, type);
 }

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd canonicalization patterns
 //===----------------------------------------------------------------------===//
 
 namespace {
 #include "ArithmeticCanonicalization.inc"
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 void arith::ConstantOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   auto type = getType();

mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp

target.addDynamicallyLegalOp<arith::IndexCastOp>(
         });
 
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void mlir::arith::populateArithmeticBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns) {
   patterns.add<BufferizeIndexCastOp>(typeConverter, patterns.getContext());
 }
 
 std::unique_ptr<Pass> mlir::arith::createArithmeticBufferizePass() {
   return std::make_unique<ArithmeticBufferizePass>();
 }

mlir/lib/Dialect/Arithmetic/Transforms/ExpandOps.cpp

void runOnFunction() override {
     >();
     // clang-format on
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void mlir::arith::populateArithmeticExpandOpsPatterns(
     RewritePatternSet &patterns) {
   // clang-format off
   patterns.add<
     CeilDivSIOpConverter,
     CeilDivUIOpConverter,
     FloorDivSIOpConverter,

mlir/lib/Dialect/Arithmetic/Transforms/PassDetail.h

 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 class StandardOpsDialect;
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Arithmetic/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_ARITHMETIC_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Async/Transforms/PassDetail.h

 
 #include "mlir/IR/Dialect.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 namespace arith {
 class ArithmeticDialect;
-} // end namespace arith
+} // namespace arith
 
 namespace async {
 class AsyncDialect;
 } // namespace async
 
 namespace scf {
 class SCFDialect;
 } // namespace scf

mlir/lib/Dialect/Bufferization/IR/BufferizationDialect.cpp

struct BufferizationInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   /// Operations in Bufferization dialect are always legal to inline.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Bufferization Dialect
 //===----------------------------------------------------------------------===//
 
 void mlir::bufferization::BufferizationDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Bufferization/IR/BufferizationOps.cpp.inc"
       >();
   addInterfaces<BufferizationInlinerInterface>();
 }

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

LogicalResult matchAndRewrite(CloneOp cloneOp,
 
     rewriter.replaceOpWithNewOp<memref::CastOp>(cloneOp, cloneOp.getType(),
                                                 source);
     rewriter.eraseOp(redundantDealloc);
     return success();
   }
 };
 
-} // namespace.
+} // namespace
 
 void CloneOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                           MLIRContext *context) {
   results.insert<SimplifyClones>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ToTensorOp

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

if (failed(deallocation.prepare()))
       return signalPassFailure();
 
     // Place all required temporary clone and dealloc nodes.
     if (failed(deallocation.deallocate()))
       return signalPassFailure();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // BufferDeallocationPass construction
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<Pass> mlir::bufferization::createBufferDeallocationPass() {
   return std::make_unique<BufferDeallocationPass>();
 }

mlir/lib/Dialect/Bufferization/Transforms/PassDetail.h

 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 class StandardOpsDialect;
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Bufferization/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_BUFFERIZATION_TRANSFORMS_PASSDETAIL_H_

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

LogicalResult matchAndRewrite(memref::DimOp dimOp,
 
     Value substituteOp = *(alloc.dynamicSizes().begin() +
                            memrefType.getDynamicDimIndex(index.value()));
     rewriter.replaceOp(dimOp, substituteOp);
     return success();
   }
 };
 
-} // end anonymous namespace.
+} // namespace
 
 void AllocOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {
   results.add<SimplifyDimOfAllocOp>(context);
 }
 
 #include "mlir/Dialect/GPU/GPUOpInterfaces.cpp.inc"
 #include "mlir/Dialect/GPU/GPUOpsEnums.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/GPU/GPUOps.cpp.inc"

mlir/lib/Dialect/GPU/Transforms/PassDetail.h

 #include "mlir/Dialect/Async/IR/Async.h"
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/GPU/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_GPU_TRANSFORMS_PASSDETAIL_H_

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

private:
   serializeISA(const std::string &isa) override;
 
   std::unique_ptr<SmallVectorImpl<char>> assembleIsa(const std::string &isa);
   std::unique_ptr<std::vector<char>>
   createHsaco(const SmallVectorImpl<char> &isaBinary);
 
   std::string getRocmPath();
 };
-} // end namespace
+} // namespace
 
 SerializeToHsacoPass::SerializeToHsacoPass(const SerializeToHsacoPass &other)
     : PassWrapper<SerializeToHsacoPass, gpu::SerializeToBlobPass>(other) {}
 
 /// Get a user-specified path to ROCm
 // Tries, in order, the --rocm-path option, the ROCM_PATH environment variable
 // and a compile-time default
 std::string SerializeToHsacoPass::getRocmPath() {

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

#define REGISTER_ENUM_TYPE(Ty)                                                 \
   template <>                                                                  \
   struct EnumTraits<Ty> {                                                      \
     static StringRef stringify(Ty value) { return stringify##Ty(value); }      \
     static unsigned getMaxEnumVal() { return getMaxEnumValFor##Ty(); }         \
   }
 
 REGISTER_ENUM_TYPE(Linkage);
 REGISTER_ENUM_TYPE(UnnamedAddr);
-} // end namespace
+} // namespace
 
 /// Parse an enum from the keyword, or default to the provided default value.
 /// The return type is the enum type by default, unless overriden with the
 /// second template argument.
 template <typename EnumTy, typename RetTy = EnumTy>
 static RetTy parseOptionalLLVMKeyword(OpAsmParser &parser,
                                       OperationState &result,
                                       EnumTy defaultValue) {

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

struct LLVMTypeAndSizeStorage : public TypeStorage {
   bool operator==(const KeyTy &key) const {
     return std::make_tuple(elementType, numElements) == key;
   }
 
   Type elementType;
   unsigned numElements;
 };
 
-} // end namespace detail
-} // end namespace LLVM
-} // end namespace mlir
+} // namespace detail
+} // namespace LLVM
+} // namespace mlir
 
 #endif // DIALECT_LLVMIR_IR_TYPEDETAIL_H

mlir/lib/Dialect/LLVMIR/Transforms/LegalizeForExport.cpp

 
 namespace {
 struct LegalizeForExportPass
     : public LLVMLegalizeForExportBase<LegalizeForExportPass> {
   void runOnOperation() override {
     LLVM::ensureDistinctSuccessors(getOperation());
   }
 };
-} // end namespace
+} // namespace
 
 std::unique_ptr<Pass> LLVM::createLegalizeForExportPass() {
   return std::make_unique<LegalizeForExportPass>();
 }

mlir/lib/Dialect/LLVMIR/Transforms/PassDetail.h

 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/LLVMIR/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_LLVMIR_TRANSFORMS_PASSDETAIL_H_

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

bool isLegalToInline(Operation *, Region *, bool,
     return true;
   }
   // Handle the given inlined terminator by replacing it with a new operation
   // as necessary. Required when the region has only one block.
   void handleTerminator(Operation *op,
                         ArrayRef<Value> valuesToRepl) const final {}
 };
 
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // LinalgDialect
 //===----------------------------------------------------------------------===//
 
 /// Attribute name used to to memoize indexing maps for named ops.
 constexpr const ::llvm::StringLiteral
     LinalgDialect::kMemoizedIndexingMapsAttrName;

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

void runOnOperation() override {
 
     RewritePatternSet patterns(&context);
     populateLinalgBufferizePatterns(typeConverter, patterns);
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<OperationPass<FuncOp>> mlir::createLinalgBufferizePass() {
   return std::make_unique<LinalgBufferizePass>();
 }
 
 void mlir::linalg::populateLinalgBufferizePatterns(
     bufferization::BufferizeTypeConverter &typeConverter,
     RewritePatternSet &patterns) {

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

void getDependentDialects(DialectRegistry &registry) const override {
     bufferization_ext::registerBufferizableOpInterfaceExternalModels(registry);
     linalg_ext::registerBufferizableOpInterfaceExternalModels(registry);
     scf_ext::registerBufferizableOpInterfaceExternalModels(registry);
     std_ext::registerBufferizableOpInterfaceExternalModels(registry);
     tensor_ext::registerBufferizableOpInterfaceExternalModels(registry);
     vector_ext::registerBufferizableOpInterfaceExternalModels(registry);
   }
 };
-} // end namespace
+} // namespace
 
 static void applyEnablingTransformations(ModuleOp moduleOp) {
   RewritePatternSet patterns(moduleOp.getContext());
   patterns.add<GeneralizePadTensorOpPattern>(moduleOp.getContext());
   (void)applyPatternsAndFoldGreedily(moduleOp, std::move(patterns));
 }
 
 static Optional<Value> allocationFnUsingAlloca(OpBuilder &b, Location loc,

mlir/lib/Dialect/Linalg/Transforms/PassDetail.h

 
 namespace mlir {
 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
 namespace arith {
 class ArithmeticDialect;
-} // end namespace arith
+} // namespace arith
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace linalg {
 class LinalgDialect;
-} // end namespace linalg
+} // namespace linalg
 
 namespace scf {
 class SCFDialect;
-} // end namespace scf
+} // namespace scf
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 namespace vector {
 class VectorDialect;
-} // end namespace vector
+} // namespace vector
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Linalg/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_LINALG_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Math/IR/MathDialect.cpp

struct MathInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   /// All operations within math ops can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void mlir::math::MathDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Math/IR/MathOps.cpp.inc"
       >();
   addInterfaces<MathInlinerInterface>();
 }

mlir/lib/Dialect/MemRef/IR/MemRefDialect.cpp

bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
                        BlockAndValueMapping &valueMapping) const final {
     return true;
   }
   bool isLegalToInline(Operation *, Region *, bool wouldBeCloned,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void mlir::memref::MemRefDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"
       >();
   addInterfaces<MemRefInlinerInterface>();
 }

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

LogicalResult matchAndRewrite(T alloc,
 
     for (Operation *user : llvm::make_early_inc_range(alloc->getUsers()))
       rewriter.eraseOp(user);
 
     rewriter.eraseOp(alloc);
     return success();
   }
 };
-} // end anonymous namespace.
+} // namespace
 
 void AllocOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                           MLIRContext *context) {
   results.add<SimplifyAllocConst<AllocOp>, SimplifyDeadAlloc<AllocOp>>(context);
 }
 
 void AllocaOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
LogicalResult matchAndRewrite(DimOp dim,
     Value load = rewriter.create<LoadOp>(loc, reshape.shape(), dim.index());
     if (load.getType() != dim.getType())
       load = rewriter.create<arith::IndexCastOp>(loc, dim.getType(), load);
     rewriter.replaceOp(dim, load);
     return success();
   }
 };
 
-} // end anonymous namespace.
+} // namespace
 
 void DimOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.add<DimOfMemRefReshape>(context);
 }
 
 // ---------------------------------------------------------------------------
 // DmaStartOp
Wrapper operator+(Wrapper a, int64_t b) {
   return Wrapper(a.v + b);
 }
 Wrapper operator*(Wrapper a, int64_t b) {
   if (ShapedType::isDynamicStrideOrOffset(a) ||
       ShapedType::isDynamicStrideOrOffset(b))
     return Wrapper(ShapedType::kDynamicStrideOrOffset);
   return Wrapper(a.v * b);
 }
-} // end namespace saturated_arith
-} // end namespace
+} // namespace saturated_arith
+} // namespace
 
 /// A subview result type can be fully inferred from the source type and the
 /// static representation of offsets, sizes and strides. Special sentinels
 /// encode the dynamic case.
 Type SubViewOp::inferResultType(MemRefType sourceMemRefType,
                                 ArrayRef<int64_t> leadingStaticOffsets,
                                 ArrayRef<int64_t> leadingStaticSizes,
                                 ArrayRef<int64_t> leadingStaticStrides) {
LogicalResult matchAndRewrite(ViewOp viewOp,
     if (!allocOp)
       return failure();
     rewriter.replaceOpWithNewOp<ViewOp>(viewOp, viewOp.getType(), allocOperand,
                                         viewOp.byte_shift(), viewOp.sizes());
     return success();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void ViewOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                          MLIRContext *context) {
   results.add<ViewOpShapeFolder, ViewOpMemrefCastFolder>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/MemRef/IR/MemRefOps.cpp.inc"

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

 /// Model for pointer-like types that already provide a `getElementType` method.
 template <typename T>
 struct PointerLikeModel
     : public PointerLikeType::ExternalModel<PointerLikeModel<T>, T> {
   Type getElementType(Type pointer) const {
     return pointer.cast<T>().getElementType();
   }
 };
-} // end namespace
+} // namespace
 
 void OpenMPDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"
       >();
 
   LLVM::LLVMPointerType::attachInterface<

mlir/lib/Dialect/Quant/Transforms/ConvertConst.cpp

 
 struct QuantizedConstRewrite : public OpRewritePattern<QuantizeCastOp> {
   using OpRewritePattern<QuantizeCastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(QuantizeCastOp qbarrier,
                                 PatternRewriter &rewriter) const override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Matches a [constant] -> [qbarrier] where the qbarrier results type is
 /// quantized and the operand type is quantizable.
 
 LogicalResult
 QuantizedConstRewrite::matchAndRewrite(QuantizeCastOp qbarrier,
                                        PatternRewriter &rewriter) const {
   Attribute value;

mlir/lib/Dialect/Quant/Transforms/PassDetail.h

 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Quant/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_QUANT_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SCF/SCF.cpp

void handleTerminator(Operation *op,
     if (!retValOp)
       return;
 
     for (auto retValue : llvm::zip(valuesToRepl, retValOp.getOperands())) {
       std::get<0>(retValue).replaceAllUsesWith(std::get<1>(retValue));
     }
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // SCFDialect
 //===----------------------------------------------------------------------===//
 
 void SCFDialect::initialize() {
   addOperations<
 #define GET_OP_LIST

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

void runOnFunction() override {
 
     bufferization::populateBufferizeMaterializationLegality(target);
     populateSCFStructuralTypeConversionsAndLegality(typeConverter, patterns,
                                                     target);
     if (failed(applyPartialConversion(func, target, std::move(patterns))))
       return signalPassFailure();
   };
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::createSCFBufferizePass() {
   return std::make_unique<SCFBufferizePass>();
 }

mlir/lib/Dialect/SCF/Transforms/PassDetail.h

 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
 class AffineDialect;
 
 namespace arith {
 class ArithmeticDialect;
-} // end namespace arith
+} // namespace arith
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 namespace tensor {
 class TensorDialect;
-} // end namespace tensor
+} // namespace tensor
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/SCF/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_LOOPOPS_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

indices.append(accessChainOp.indices().begin(),
                    accessChainOp.indices().end());
 
     rewriter.replaceOpWithNewOp<spirv::AccessChainOp>(
         accessChainOp, parentAccessChainOp.base_ptr(), indices);
 
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void spirv::AccessChainOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<CombineChainedAccessChain>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.BitcastOp
LogicalResult ConvertSelectionOpToSelect::canCanonicalizeSelection(
 
   if ((trueBrBranchOp->getSuccessor(0) != mergeBlock) ||
       (falseBrBranchOp->getSuccessor(0) != mergeBlock)) {
     return failure();
   }
 
   return success();
 }
-} // end anonymous namespace
+} // namespace
 
 void spirv::SelectionOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                      MLIRContext *context) {
   results.add<ConvertSelectionOpToSelect>(context);
 }

mlir/lib/Dialect/SPIRV/IR/SPIRVGLSLCanonicalization.cpp

 #include "mlir/Dialect/SPIRV/IR/SPIRVGLSLCanonicalization.h"
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 
 using namespace mlir;
 
 namespace {
 #include "SPIRVCanonicalization.inc"
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace spirv {
 void populateSPIRVGLSLCanonicalizationPatterns(RewritePatternSet &results) {
   results.add<ConvertComparisonIntoClampSPV_FOrdLessThanOp,
               ConvertComparisonIntoClampSPV_FOrdLessThanEqualOp,
               ConvertComparisonIntoClampSPV_SLessThanOp,
               ConvertComparisonIntoClampSPV_SLessThanEqualOp,
               ConvertComparisonIntoClampSPV_ULessThanOp,
               ConvertComparisonIntoClampSPV_ULessThanEqualOp>(
       results.getContext());
 }
 } // namespace spirv
 } // namespace mlir

mlir/lib/Dialect/SPIRV/Transforms/PassDetail.h

 #define DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 namespace spirv {
 class ModuleOp;
-} // end namespace spirv
+} // namespace spirv
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_SPIRV_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/SPIRV/Transforms/RewriteInsertsPass.cpp

private:
   /// Collects a sequential insertion chain by the given
   /// `spirv::CompositeInsertOp` operation, if the given operation is the last
   /// in the chain.
   LogicalResult
   collectInsertionChain(spirv::CompositeInsertOp op,
                         SmallVectorImpl<spirv::CompositeInsertOp> &insertions);
 };
 
-} // anonymous namespace
+} // namespace
 
 void RewriteInsertsPass::runOnOperation() {
   SmallVector<SmallVector<spirv::CompositeInsertOp, 4>, 4> workList;
   getOperation().walk([this, &workList](spirv::CompositeInsertOp op) {
     SmallVector<spirv::CompositeInsertOp, 4> insertions;
     if (succeeded(collectInsertionChain(op, insertions)))
       workList.push_back(insertions);
   });

mlir/lib/Dialect/Shape/Transforms/PassDetail.h

 #define DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Shape/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_SHAPE_TRANSFORMS_PASSDETAIL_H_

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

void runOnOperation() override {
     populateCallOpTypeConversionPattern(patterns, converter);
     populateSparseTensorConversionPatterns(converter, patterns);
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::createSparsificationPass() {
   return std::make_unique<SparsificationPass>();
 }
 
 std::unique_ptr<Pass> mlir::createSparseTensorConversionPass() {
   return std::make_unique<SparseTensorConversionPass>();
 }

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

void handleTerminator(Operation *op,
     auto returnOp = cast<ReturnOp>(op);
 
     // Replace the values directly with the return operands.
     assert(returnOp.getNumOperands() == valuesToRepl.size());
     for (const auto &it : llvm::enumerate(returnOp.getOperands()))
       valuesToRepl[it.index()].replaceAllUsesWith(it.value());
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // StandardOpsDialect
 //===----------------------------------------------------------------------===//
 
 void StandardOpsDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
if (condbr.getFalseDest()->getSinglePredecessor()) {
           rewriter.updateRootInPlace(use.getOwner(),
                                      [&] { use.set(constantFalse); });
         }
       }
     }
     return success(replaced);
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void CondBranchOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<SimplifyConstCondBranchPred, SimplifyPassThroughCondBranch,
               SimplifyCondBranchIdenticalSuccessors,
               SimplifyCondBranchFromCondBranchOnSameCondition,
               CondBranchTruthPropagation>(context);
 }

mlir/lib/Dialect/StandardOps/Transforms/FuncConversions.cpp

matchAndRewrite(CallOp callOp, OpAdaptor adaptor,
 
     // Substitute with the new result types from the corresponding FuncType
     // conversion.
     rewriter.replaceOpWithNewOp<CallOp>(
         callOp, callOp.getCallee(), convertedResults, adaptor.getOperands());
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void mlir::populateCallOpTypeConversionPattern(RewritePatternSet &patterns,
                                                TypeConverter &converter) {
   patterns.add<CallOpSignatureConversion>(converter, patterns.getContext());
 }
 
 namespace {
 /// Only needed to support partial conversion of functions where this pattern
matchAndRewrite(BranchOpInterface op, ArrayRef<Value> operands,
     rewriter.updateRootInPlace(
         op, [newOperands, op]() { op->setOperands(newOperands); });
     return success();
   }
 
 private:
   function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand;
 };
-} // end anonymous namespace
+} // namespace
 
 namespace {
 /// Only needed to support partial conversion of functions where this pattern
 /// ensures that the branch operation arguments matches up with the succesor
 /// block arguments.
 class ReturnOpTypeConversion : public OpConversionPattern<ReturnOp> {
 public:
   using OpConversionPattern<ReturnOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(ReturnOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     // For a return, all operands go to the results of the parent, so
     // rewrite them all.
     rewriter.updateRootInPlace(op,
                                [&] { op->setOperands(adaptor.getOperands()); });
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void mlir::populateBranchOpInterfaceTypeConversionPattern(
     RewritePatternSet &patterns, TypeConverter &typeConverter,
     function_ref<bool(BranchOpInterface, int)> shouldConvertBranchOperand) {
   patterns.insert<BranchOpInterfaceTypeConversion>(
       typeConverter, patterns.getContext(), shouldConvertBranchOperand);
 }
 

mlir/lib/Dialect/StandardOps/Transforms/PassDetail.h

 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 class AtomicRMWOp;
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/StandardOps/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_STANDARD_TRANSFORMS_PASSDETAIL_H_

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

bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
                        BlockAndValueMapping &valueMapping) const final {
     return true;
   }
   bool isLegalToInline(Operation *, Region *, bool wouldBeCloned,
                        BlockAndValueMapping &) const final {
     return true;
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // TensorDialect Methods
 //===----------------------------------------------------------------------===//
 
 void TensorDialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/Tensor/IR/TensorOps.cpp.inc"
       >();
   addInterfaces<TensorInlinerInterface>();
 }

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

LogicalResult matchAndRewrite(DimOp dimOp,
     auto castOp = dimOp.source().getDefiningOp<CastOp>();
     if (!castOp)
       return failure();
     Value newSource = castOp.getOperand();
     rewriter.replaceOpWithNewOp<DimOp>(dimOp, newSource, dimOp.index());
     return success();
   }
 };
-} // end anonymous namespace.
+} // namespace
 
 void DimOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                         MLIRContext *context) {
   results.add<DimOfCastOp>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Tensor/Transforms/PassDetail.h

 #define DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_
 
 #include "mlir/Pass/Pass.h"
 
 namespace mlir {
 
 namespace bufferization {
 class BufferizationDialect;
-} // end namespace bufferization
+} // namespace bufferization
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 namespace scf {
 class SCFDialect;
-} // end namespace scf
+} // namespace scf
 
 #define GEN_PASS_CLASSES
 #include "mlir/Dialect/Tensor/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // DIALECT_TENSOR_TRANSFORMS_PASSDETAIL_H_

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

struct TosaInlinerInterface : public DialectInlinerInterface {
 
   /// All regions with If and While parent operators can be inlined.
   bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
                        BlockAndValueMapping &map) const final {
     return (isa<tosa::IfOp>(dest->getParentOp()) ||
             isa<tosa::WhileOp>(dest->getParentOp()));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // TOSA control flow support.
 //===----------------------------------------------------------------------===//
 
 /// Returns the while loop body.
 Region &tosa::WhileOp::getLoopBody() { return body(); }
 

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp

void runOnFunction() override {
     auto func = getFunction();
     RewritePatternSet patterns(func.getContext());
     patterns
         .insert<TransposeConvDilatedConverter, TransposeConvStridedConverter>(
             func.getContext());
     (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaDecomposeTransposeConvPass() {
   return std::make_unique<TosaDecomposeTransposeConv>();
 }

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

func.walk([&](ReturnOp op) {
       }
 
       if (castAdded) {
         rewriter.replaceOpWithNewOp<ReturnOp>(op, castedValues);
       }
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaInferShapesPass() {
   return std::make_unique<TosaInferShapes>();
 }

mlir/lib/Dialect/Tosa/Transforms/TosaMakeBroadcastable.cpp

if (reshapeLowerToHigher(rewriter, tosaBinaryOp.getLoc(), outputType,
       return failure();
 
     rewriter.replaceOpWithNewOp<tosa::ArithmeticRightShiftOp>(
         tosaBinaryOp, outputType, outInput1, outInput2, round);
 
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace {
 /// Pass that enables broadcast by making all input arrays have the same
 /// number of dimensions. Insert RESHAPE operations to lower rank operand
 struct TosaMakeBroadcastable
     : public TosaMakeBroadcastableBase<TosaMakeBroadcastable> {
 public:
   void runOnFunction() override {
void runOnFunction() override {
     patterns.add<ConvertTosaOp<tosa::LogicalRightShiftOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::LogicalAndOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::LogicalOrOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::LogicalXorOp>>(ctx);
     patterns.add<ConvertTosaOp<tosa::PowOp>>(ctx);
     (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::tosa::createTosaMakeBroadcastablePass() {
   return std::make_unique<TosaMakeBroadcastable>();
 }

mlir/lib/Dialect/Vector/VectorOps.cpp

LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
     auto splat = op.vector().getDefiningOp<SplatOp>();
     if (!splat)
       return failure();
     rewriter.replaceOpWithNewOp<SplatOp>(op, op.getType(), splat.getInput());
     return success();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void ExtractStridedSliceOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   // Pattern to rewrite a ExtractStridedSliceOp(ConstantMaskOp) ->
   // ConstantMaskOp and ExtractStridedSliceOp(ConstantOp) -> ConstantOp.
   results.add<StridedSliceConstantMaskFolder, StridedSliceConstantFolder,
               StridedSliceBroadcast, StridedSliceSplat>(context);
 }
LogicalResult matchAndRewrite(vector::TransposeOp transposeOp,
     rewriter.replaceOpWithNewOp<vector::TransposeOp>(
         transposeOp, transposeOp.getResult().getType(),
         parentTransposeOp.vector(),
         vector::getVectorSubscriptAttr(rewriter, permutation));
     return success();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void vector::TransposeOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<TransposeFolder>(context);
 }
 
 void vector::TransposeOp::getTransp(SmallVectorImpl<int64_t> &results) {
   populateFromInt64AttrArray(transp(), results);
LogicalResult matchAndRewrite(CreateMaskOp createMaskOp,
     // Replace 'createMaskOp' with ConstantMaskOp.
     rewriter.replaceOpWithNewOp<ConstantMaskOp>(
         createMaskOp, createMaskOp.getResult().getType(),
         vector::getVectorSubscriptAttr(rewriter, maskDimSizes));
     return success();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void CreateMaskOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<CreateMaskFolder>(context);
 }
 
 void mlir::vector::populateVectorToVectorCanonicalizationPatterns(
     RewritePatternSet &patterns) {

mlir/lib/ExecutionEngine/JitRunner.cpp

llvm::function_ref<std::unique_ptr<llvm::Module>(ModuleOp,
       llvmModuleBuilder;
 
   /// A custom function that is passed to ExecutinEngine to register symbols at
   /// runtime.
   llvm::function_ref<llvm::orc::SymbolMap(llvm::orc::MangleAndInterner)>
       runtimeSymbolMap;
 };
 
-} // end anonymous namespace
+} // namespace
 
 static OwningModuleRef parseMLIRInput(StringRef inputFilename,
                                       MLIRContext *context) {
   // Set up the input file.
   std::string errorMessage;
   auto file = openInputFile(inputFilename, &errorMessage);
   if (!file) {
     llvm::errs() << errorMessage << "\n";

mlir/lib/ExecutionEngine/SparseTensorUtils.cpp

for (uint64_t k = 0; k < nnz; k++) {
     if (is_symmetric && indices[0] != indices[1])
       tensor->add({indices[1], indices[0]}, value);
   }
   // Close the file and return tensor.
   fclose(file);
   return tensor;
 }
 
-} // anonymous namespace
+} // namespace
 
 extern "C" {
 
 /// This type is used in the public API at all places where MLIR expects
 /// values with the built-in type "index". For now, we simply assume that
 /// type is 64-bit, but targets with different "index" bit widths should link
 /// with an alternatively built runtime support library.
 // TODO: support such targets?

mlir/lib/IR/AffineExprDetail.h

construct(StorageUniquer::StorageAllocator &allocator, const KeyTy &key) {
     result->constant = key;
     return result;
   }
 
   // The constant.
   int64_t constant;
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 #endif // MLIR_IR_AFFINEEXPRDETAIL_H_

mlir/lib/IR/AffineMap.cpp

private:
   }
 
   // The number of dimension operands in AffineMap containing this expression.
   unsigned numDims;
   // The constant valued operands used to evaluate this AffineExpr.
   ArrayRef<Attribute> operandConsts;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Returns a single constant result affine map.
 AffineMap AffineMap::getConstantMap(int64_t val, MLIRContext *context) {
   return get(/*dimCount=*/0, /*symbolCount=*/0,
              {getAffineConstantExpr(val, context)});
 }
 
 /// Returns an identity affine map (d0, ..., dn) -> (dp, ..., dn) on the most

mlir/lib/IR/AffineMapDetail.h

construct(StorageUniquer::StorageAllocator &allocator, const KeyTy &key) {
     auto *res = new (allocator.allocate<AffineMapStorage>()) AffineMapStorage();
     res->numDims = std::get<0>(key);
     res->numSymbols = std::get<1>(key);
     res->results = allocator.copyInto(std::get<2>(key));
     return res;
   }
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 #endif // AFFINEMAPDETAIL_H_

mlir/lib/IR/AsmPrinter.cpp

llvm::cl::opt<bool> printGenericOpFormOpt{
       "mlir-print-op-generic", llvm::cl::init(false),
       llvm::cl::desc("Print the generic op form"), llvm::cl::Hidden};
 
   llvm::cl::opt<bool> printLocalScopeOpt{
       "mlir-print-local-scope", llvm::cl::init(false),
       llvm::cl::desc("Print assuming in local scope by default"),
       llvm::cl::Hidden};
 };
-} // end anonymous namespace
+} // namespace
 
 static llvm::ManagedStatic<AsmPrinterOptions> clOptions;
 
 /// Register a set of useful command-line options that can be used to configure
 /// various flags within the AsmPrinter.
 void mlir::registerAsmPrinterCLOptions() {
   // Make sure that the options struct has been initialized.
   *clOptions;

 struct NewLineCounter {
   unsigned curLine = 1;
 };
 
 static raw_ostream &operator<<(raw_ostream &os, NewLineCounter &newLine) {
   ++newLine.curLine;
   return os << '\n';
 }
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // AliasInitializer
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class represents a specific instance of a symbol Alias.
 class SymbolAlias {
private:
   const OpPrintingFlags &printerFlags;
 
   /// The initializer to use when identifying aliases.
   AliasInitializer &initializer;
 
   /// A dummy output stream.
   mutable llvm::raw_null_ostream os;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Sanitize the given name such that it can be used as a valid identifier. If
 /// the string needs to be modified in any way, the provided buffer is used to
 /// store the new copy,
 static StringRef sanitizeIdentifier(StringRef name, SmallString<16> &buffer,
                                     StringRef allowedPunctChars = "$._-",
                                     bool allowTrailingDigit = true) {
   assert(!name.empty() && "Shouldn't have an empty name here");
private:
   /// Mapping between attribute and alias.
   llvm::MapVector<Attribute, SymbolAlias> attrToAlias;
   /// Mapping between type and alias.
   llvm::MapVector<Type, SymbolAlias> typeToAlias;
 
   /// An allocator used for alias names.
   llvm::BumpPtrAllocator aliasAllocator;
 };
-} // end anonymous namespace
+} // namespace
 
 void AliasState::initialize(
     Operation *op, const OpPrintingFlags &printerFlags,
     DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
   AliasInitializer initializer(interfaces, aliasAllocator);
   initializer.initialize(op, printerFlags, attrToAlias, typeToAlias);
 }
 
private:
   unsigned nextConflictID = 0;
 
   /// These are the printing flags.  They control, eg., whether to print in
   /// generic form.
   OpPrintingFlags printerFlags;
 
   DialectInterfaceCollection<OpAsmDialectInterface> &interfaces;
 };
-} // end anonymous namespace
+} // namespace
 
 SSANameState::SSANameState(
     Operation *op, const OpPrintingFlags &printerFlags,
     DialectInterfaceCollection<OpAsmDialectInterface> &interfaces)
     : printerFlags(printerFlags), interfaces(interfaces) {
   llvm::SaveAndRestore<unsigned> valueIDSaver(nextValueID);
   llvm::SaveAndRestore<unsigned> argumentIDSaver(nextArgumentID);
   llvm::SaveAndRestore<unsigned> conflictIDSaver(nextConflictID);
private:
   SSANameState nameState;
 
   /// Flags that control op output.
   OpPrintingFlags printerFlags;
 
   /// An optional location map to be populated.
   AsmState::LocationMap *locationMap;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 AsmState::AsmState(Operation *op, const OpPrintingFlags &printerFlags,
                    LocationMap *locationMap)
     : impl(std::make_unique<AsmStateImpl>(op, printerFlags, locationMap)) {}
 AsmState::~AsmState() {}
 
 //===----------------------------------------------------------------------===//
 // AsmPrinter::Impl
private:
   SmallVector<StringRef> defaultDialectStack{"builtin"};
 
   /// The number of spaces used for indenting nested operations.
   const static unsigned indentWidth = 2;
 
   // This is the current indentation level for nested structures.
   unsigned currentIndent = 0;
 };
-} // end anonymous namespace
+} // namespace
 
 void OperationPrinter::printTopLevelOperation(Operation *op) {
   // Output the aliases at the top level that can't be deferred.
   state->getAliasState().printNonDeferredAliases(os, newLine);
 
   // Print the module.
   print(op);
   os << newLine;

mlir/lib/IR/BuiltinDialect.cpp

if (auto tupleType = type.dyn_cast<TupleType>()) {
       if (tupleType.size() > 16) {
         os << "tuple";
         return AliasResult::OverridableAlias;
       }
     }
     return AliasResult::NoAlias;
   }
 };
-} // end anonymous namespace.
+} // namespace
 
 void BuiltinDialect::initialize() {
   registerTypes();
   registerAttributes();
   registerLocationAttributes();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/IR/BuiltinOps.cpp.inc"

mlir/lib/IR/Diagnostics.cpp

unsigned id =
         mgr.AddIncludeFile(std::string(filename), llvm::SMLoc(), ignored);
     filenameToBufId[filename] = id;
     return id;
   }
 
   /// Mapping between file name and buffer ID's.
   llvm::StringMap<unsigned> filenameToBufId;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 /// Return a processable FileLineColLoc from the given location.
 static Optional<FileLineColLoc> getFileLineColLoc(Location loc) {
   Optional<FileLineColLoc> firstFileLoc;
   loc->walk([&](Location loc) {
     if (FileLineColLoc fileLoc = loc.dyn_cast<FileLineColLoc>()) {
       firstFileLoc = fileLoc;
       return WalkResult::interrupt();
struct SourceMgrDiagnosticVerifierHandlerImpl {
 
   /// A list of expected diagnostics for each buffer of the source manager.
   llvm::StringMap<SmallVector<ExpectedDiag, 2>> expectedDiagsPerFile;
 
   /// Regex to match the expected diagnostics format.
   llvm::Regex expected = llvm::Regex("expected-(error|note|remark|warning) "
                                      "*(@([+-][0-9]+|above|below))? *{{(.*)}}");
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 /// Given a diagnostic kind, return a human readable string for it.
 static StringRef getDiagKindStr(DiagnosticSeverity kind) {
   switch (kind) {
   case DiagnosticSeverity::Note:
     return "note";
   case DiagnosticSeverity::Warning:
     return "warning";
struct ParallelDiagnosticHandlerImpl : public llvm::PrettyStackTraceEntry {
   mutable std::vector<ThreadDiagnostic> diagnostics;
 
   /// The unique id for the parallel handler.
   DiagnosticEngine::HandlerID handlerID;
 
   /// The context to emit the diagnostics to.
   MLIRContext *context;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 ParallelDiagnosticHandler::ParallelDiagnosticHandler(MLIRContext *ctx)
     : impl(new ParallelDiagnosticHandlerImpl(ctx)) {}
 ParallelDiagnosticHandler::~ParallelDiagnosticHandler() {}
 
 /// Set the order id for the current thread.
 void ParallelDiagnosticHandler::setOrderIDForThread(size_t orderID) {
   impl->setOrderIDForThread(orderID);
 }
 
 /// Remove the order id for the current thread. This removes the thread from
 /// diagnostics tracking.
 void ParallelDiagnosticHandler::eraseOrderIDForThread() {
   impl->eraseOrderIDForThread();
 }

mlir/lib/IR/Dialect.cpp

 llvm::unique_function<void(Operation *, OpAsmPrinter &printer)>
 Dialect::getOperationPrinter(Operation *op) const {
   assert(op->getDialect() == this &&
          "Dialect hook invoked on non-dialect owned operation");
   return nullptr;
 }
 
 /// Utility function that returns if the given string is a valid dialect
-/// namespace.
+/// namespace
 bool Dialect::isValidNamespace(StringRef str) {
   llvm::Regex dialectNameRegex("^[a-zA-Z_][a-zA-Z_0-9\\$]*$");
   return dialectNameRegex.match(str);
 }
 
 /// Register a set of dialect interfaces with this dialect instance.
 void Dialect::addInterface(std::unique_ptr<DialectInterface> interface) {
   auto it = registeredInterfaces.try_emplace(interface->getID(),

mlir/lib/IR/IntegerSetDetail.h

construct(StorageUniquer::StorageAllocator &allocator, const KeyTy &key) {
     res->dimCount = std::get<0>(key);
     res->symbolCount = std::get<1>(key);
     res->constraints = allocator.copyInto(std::get<2>(key));
     res->eqFlags = allocator.copyInto(std::get<3>(key));
     return res;
   }
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 #endif // INTEGERSETDETAIL_H_

mlir/lib/IR/MLIRContext.cpp

llvm::cl::opt<bool> printOpOnDiagnostic{
                      "the operation as an attached note"),
       llvm::cl::init(true)};
 
   llvm::cl::opt<bool> printStackTraceOnDiagnostic{
       "mlir-print-stacktrace-on-diagnostic",
       llvm::cl::desc("When a diagnostic is emitted, also print the stack trace "
                      "as an attached note")};
 };
-} // end anonymous namespace
+} // namespace
 
 static llvm::ManagedStatic<MLIRContextOptions> clOptions;
 
 static bool isThreadingGloballyDisabled() {
 #if LLVM_ENABLE_THREADS != 0
   return clOptions.isConstructed() && clOptions->disableThreading;
 #else
   return true;
if (mutex)
       mutex->lock();
   }
   ~ScopedWriterLock() {
     if (mutex)
       mutex->unlock();
   }
   llvm::sys::SmartRWMutex<true> *mutex;
 };
-} // end anonymous namespace.
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // MLIRContextImpl
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 /// This is the implementation of the MLIRContext class, using the pImpl idiom.
 /// This class is completely private to this file, so everything is public.
public:
   }
   ~MLIRContextImpl() {
     for (auto typeMapping : registeredTypes)
       typeMapping.second->~AbstractType();
     for (auto attrMapping : registeredAttributes)
       attrMapping.second->~AbstractAttribute();
   }
 };
-} // end namespace mlir
+} // namespace mlir
 
 MLIRContext::MLIRContext(Threading setting)
     : MLIRContext(DialectRegistry(), setting) {}
 
 MLIRContext::MLIRContext(const DialectRegistry &registry, Threading setting)
     : impl(new MLIRContextImpl(setting == Threading::ENABLED &&
                                !isThreadingGloballyDisabled())) {
   // Initialize values based on the command line flags if they were provided.

mlir/lib/IR/SymbolTable.cpp

struct SymbolScope {
   }
 
   /// The representation of the symbol within this scope.
   SymbolRefAttr symbol;
 
   /// The IR unit representing this scope.
   llvm::PointerUnion<Operation *, Region *> limit;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Collect all of the symbol scopes from 'symbol' to (inclusive) 'limit'.
 static SmallVector<SymbolScope, 2> collectSymbolScopes(Operation *symbol,
                                                        Operation *limit) {
   StringAttr symName = SymbolTable::getSymbolName(symbol);
   assert(!symbol->hasTrait<OpTrait::SymbolTable>() || symbol != limit);
 
   // Compute the ancestors of 'limit'.

mlir/lib/IR/Verifier.cpp

private:
   verifyOperation(Operation &op,
                   SmallVectorImpl<Operation *> &opsWithIsolatedRegions);
 
   /// Verify the dominance property of regions contained within the given
   /// Operation.
   LogicalResult verifyDominanceOfContainedRegions(Operation &op,
                                                   DominanceInfo &domInfo);
 };
-} // end anonymous namespace
+} // namespace
 
 LogicalResult OperationVerifier::verifyOpAndDominance(Operation &op) {
   SmallVector<Operation *> opsWithIsolatedRegions;
 
   // Verify the operation first, collecting any IsolatedFromAbove operations.
   if (failed(verifyOperation(op, opsWithIsolatedRegions)))
     return failure();
 

mlir/lib/Parser/AffineParser.cpp

 
 private:
   bool allowParsingSSAIds;
   function_ref<ParseResult(bool)> parseElement;
   unsigned numDimOperands;
   unsigned numSymbolOperands;
   SmallVector<std::pair<StringRef, AffineExpr>, 4> dimsAndSymbols;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Create an affine binary high precedence op expression (mul's, div's, mod).
 /// opLoc is the location of the op token to be used to report errors
 /// for non-conforming expressions.
 AffineExpr AffineParser::getAffineBinaryOpExpr(AffineHighPrecOp op,
                                                AffineExpr lhs, AffineExpr rhs,
                                                SMLoc opLoc) {
   // TODO: make the error location info accurate.

mlir/lib/Parser/AsmParserImpl.h

protected:
 
   /// The main parser.
   Parser &parser;
 
   /// A flag that indicates if any errors were emitted during parsing.
   bool emittedError = false;
 };
 } // namespace detail
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_LIB_PARSER_ASMPARSERIMPL_H

mlir/lib/Parser/AttributeParser.cpp

private:
   SmallVector<int64_t, 4> shape;
 
   /// Storage used when parsing elements, this is a pair of <is_negated, token>.
   std::vector<std::pair<bool, Token>> storage;
 
   /// Storage used when parsing elements that were stored as hex values.
   Optional<Token> hexStorage;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Parse the elements of a tensor literal. If 'allowHex' is true, the parser
 /// may also parse a tensor literal that is store as a hex string.
 ParseResult TensorLiteralParser::parse(bool allowHex) {
   // If hex is allowed, check for a string literal.
   if (allowHex && p.getToken().is(Token::string)) {
     hexStorage = p.getToken();
     p.consumeToken(Token::string);

mlir/lib/Parser/Lexer.h

private:
 
   StringRef curBuffer;
   const char *curPtr;
 
   Lexer(const Lexer &) = delete;
   void operator=(const Lexer &) = delete;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_LIB_PARSER_LEXER_H

mlir/lib/Parser/Parser.h

public:
   parseAffineExprOfSSAIds(AffineExpr &expr,
                           function_ref<ParseResult(bool)> parseElement);
 
 protected:
   /// The Parser is subclassed and reinstantiated.  Do not add additional
   /// non-trivial state here, add it to the ParserState class.
   ParserState &state;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 #endif // MLIR_LIB_PARSER_PARSER_H

mlir/lib/Parser/Parser.cpp

SmallVector<std::pair<OpOrArgument, Token>, 8>
       opsAndArgumentsWithDeferredLocs;
 
   /// The builder used when creating parsed operation instances.
   OpBuilder opBuilder;
 
   /// The top level operation that holds all of the parsed operations.
   Operation *topLevelOp;
 };
-} // end anonymous namespace
+} // namespace
 
 OperationParser::OperationParser(ParserState &state, ModuleOp topLevelOp)
     : Parser(state), opBuilder(topLevelOp.getRegion()), topLevelOp(topLevelOp) {
   // The top level operation starts a new name scope.
   pushSSANameScope(/*isIsolated=*/true);
 
   // If we are populating the parser state, prepare it for parsing.
   if (state.asmState)
private:
   /// The abstract information of the operation.
   function_ref<ParseResult(OpAsmParser &, OperationState &)> parseAssembly;
   bool isIsolatedFromAbove;
   StringRef opName;
 
   /// The backing operation parser.
   OperationParser &parser;
 };
-} // end anonymous namespace.
+} // namespace
 
 FailureOr<OperationName> OperationParser::parseCustomOperationName() {
   std::string opName = getTokenSpelling().str();
   if (opName.empty())
     return (emitError("empty operation name is invalid"), failure());
 
   consumeToken();
 

 
 private:
   /// Parse an attribute alias declaration.
   ParseResult parseAttributeAliasDef();
 
   /// Parse an attribute alias declaration.
   ParseResult parseTypeAliasDef();
 };
-} // end anonymous namespace
+} // namespace
 
 /// Parses an attribute alias declaration.
 ///
 ///   attribute-alias-def ::= '#' alias-name `=` attribute-value
 ///
 ParseResult TopLevelOperationParser::parseAttributeAliasDef() {
   assert(getToken().is(Token::hash_identifier));
   StringRef aliasName = getTokenSpelling().drop_front();

mlir/lib/Parser/ParserState.h

struct ParserState {
   // Contains the stack of default dialect to use when parsing regions.
   // A new dialect get pushed to the stack before parsing regions nested
   // under an operation implementing `OpAsmOpInterface`, and
   // popped when done. At the top-level we start with "builtin" as the
   // default, so that the top-level `module` operation parses as-is.
   SmallVector<StringRef> defaultDialectStack{"builtin"};
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 #endif // MLIR_LIB_PARSER_PARSERSTATE_H

mlir/lib/Parser/Token.h

private:
   /// Discriminator that indicates the sort of token this is.
   Kind kind;
 
   /// A reference to the entire token contents; this is always a pointer into
   /// a memory buffer owned by the source manager.
   StringRef spelling;
 };
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // MLIR_LIB_PARSER_TOKEN_H

mlir/lib/Pass/IRPrinting.cpp

private:
   /// Configuration to use.
   std::unique_ptr<PassManager::IRPrinterConfig> config;
 
   /// The following is a set of fingerprints for operations that are currently
   /// being operated on in a pass. This field is only used when the
   /// configuration asked for change detection.
   DenseMap<Pass *, OperationFingerPrint> beforePassFingerPrints;
 };
-} // end anonymous namespace
+} // namespace
 
 static void printIR(Operation *op, bool printModuleScope, raw_ostream &out,
                     OpPrintingFlags flags) {
   // Otherwise, check to see if we are not printing at module scope.
   if (!printModuleScope)
     return op->print(out << " //----- //\n",
                      op->getBlock() ? flags.useLocalScope() : flags);
 
struct BasicIRPrinterConfig : public PassManager::IRPrinterConfig {
 
   /// Filter functions for before and after pass execution.
   std::function<bool(Pass *, Operation *)> shouldPrintBeforePass;
   std::function<bool(Pass *, Operation *)> shouldPrintAfterPass;
 
   /// The stream to output to.
   raw_ostream &out;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Add an instrumentation to print the IR before and after pass execution,
 /// using the provided configuration.
 void PassManager::enableIRPrinting(std::unique_ptr<IRPrinterConfig> config) {
   if (config->shouldPrintAtModuleScope() &&
       getContext()->isMultithreadingEnabled())
     llvm::report_fatal_error("IR printing can't be setup on a pass-manager "
                              "without disabling multi-threading first.");

mlir/lib/Pass/Pass.cpp

struct OpPassManagerImpl {
   /// The current initialization generation of this pass manager. This is used
   /// to indicate when a pass manager should be reinitialized.
   unsigned initializationGeneration;
 
   /// Control the implicit nesting of passes that mismatch the name set for this
   /// OpPassManager.
   OpPassManager::Nesting nesting;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 void OpPassManagerImpl::mergeInto(OpPassManagerImpl &rhs) {
   assert(name == rhs.name && "merging unrelated pass managers");
   for (auto &pass : passes)
     rhs.passes.push_back(std::move(pass));
   passes.clear();
 }
 

 namespace detail {
 struct PassInstrumentorImpl {
   /// Mutex to keep instrumentation access thread-safe.
   llvm::sys::SmartMutex<true> mutex;
 
   /// Set of registered instrumentations.
   std::vector<std::unique_ptr<PassInstrumentation>> instrumentations;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 PassInstrumentor::PassInstrumentor() : impl(new PassInstrumentorImpl()) {}
 PassInstrumentor::~PassInstrumentor() {}
 
 /// See PassInstrumentation::runBeforePipeline for details.
 void PassInstrumentor::runBeforePipeline(
     StringAttr name,
     const PassInstrumentation::PipelineParentInfo &parentInfo) {

mlir/lib/Pass/PassCrashRecovery.cpp

struct CrashReproducerInstrumentation : public PassInstrumentation {
   void runAfterPassFailed(Pass *pass, Operation *op) override {
     generator.finalize(op, /*executionResult=*/failure());
   }
 
 private:
   /// The generator used to create crash reproducers.
   PassCrashReproducerGenerator &generator;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // FileReproducerStream
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class represents a default instance of PassManager::ReproducerStream
 /// that is backed by a file.
 struct FileReproducerStream : public PassManager::ReproducerStream {
   FileReproducerStream(std::unique_ptr<llvm::ToolOutputFile> outputFile)
       : outputFile(std::move(outputFile)) {}
   ~FileReproducerStream() override { outputFile->keep(); }
 
   /// Returns a description of the reproducer stream.
   StringRef description() override { return outputFile->getFilename(); }
 
   /// Returns the stream on which to output the reproducer.
   raw_ostream &os() override { return outputFile->os(); }
 
 private:
   /// ToolOutputFile corresponding to opened `filename`.
   std::unique_ptr<llvm::ToolOutputFile> outputFile = nullptr;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // PassManager
 //===----------------------------------------------------------------------===//
 
 LogicalResult PassManager::runWithCrashRecovery(Operation *op,
                                                 AnalysisManager am) {
   crashReproGenerator->initialize(getPasses(), op, verifyPasses);

mlir/lib/Pass/PassDetail.h

 
 private:
   struct Impl;
 
   /// The internal implementation of the crash reproducer.
   std::unique_ptr<Impl> impl;
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 #endif // MLIR_PASS_PASSDETAIL_H_

mlir/lib/Pass/PassManagerOptions.cpp

llvm::cl::opt<PassDisplayMode> passStatisticsDisplayMode{
       llvm::cl::init(PassDisplayMode::Pipeline),
       llvm::cl::values(
           clEnumValN(
               PassDisplayMode::List, "list",
               "display the results in a merged list sorted by pass name"),
           clEnumValN(PassDisplayMode::Pipeline, "pipeline",
                      "display the results with a nested pipeline view"))};
 };
-} // end anonymous namespace
+} // namespace
 
 static llvm::ManagedStatic<PassManagerOptions> options;
 
 /// Add an IR printing instrumentation if enabled by any 'print-ir' flags.
 void PassManagerOptions::addPrinterInstrumentation(PassManager &pm) {
   std::function<bool(Pass *, Operation *)> shouldPrintBeforePass;
   std::function<bool(Pass *, Operation *)> shouldPrintAfterPass;
 

mlir/lib/Pass/PassRegistry.cpp

private:
   /// Add the given pipeline elements to the provided pass manager.
   LogicalResult
   addToPipeline(ArrayRef<PipelineElement> elements, OpPassManager &pm,
                 function_ref<LogicalResult(const Twine &)> errorHandler) const;
 
   std::vector<PipelineElement> pipeline;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Try to initialize this pipeline with the given pipeline text. An option is
 /// given to enable accurate error reporting.
 LogicalResult TextualPipeline::initialize(StringRef text,
                                           raw_ostream &errorStream) {
   if (text.empty())
     return success();
 
struct PassArgData {
   /// This field is set when instance specific pass options have been provided
   /// on the command line.
   StringRef options;
 
   /// This field is used when the parsed option corresponds to an explicit
   /// pipeline.
   TextualPipeline pipeline;
 };
-} // end anonymous namespace
+} // namespace
 
 namespace llvm {
 namespace cl {
 /// Define a valid OptionValue for the command line pass argument.
 template <>
 struct OptionValue<PassArgData> final
     : OptionValueBase<PassArgData, /*isClass=*/true> {
   OptionValue(const PassArgData &value) { this->setValue(value); }
   OptionValue() = default;
   void anchor() override {}
 
   bool hasValue() const { return true; }
   const PassArgData &getValue() const { return value; }
   void setValue(const PassArgData &value) { this->value = value; }
 
   PassArgData value;
 };
-} // end namespace cl
-} // end namespace llvm
+} // namespace cl
+} // namespace llvm
 
 namespace {
 
 /// The name for the command line option used for parsing the textual pass
 /// pipeline.
 static constexpr StringLiteral passPipelineArg = "pass-pipeline";
 
 /// Adds command line option for each registered pass or pass pipeline, as well
bool contains(const PassRegistryEntry *entry) const {
     return llvm::any_of(passList, [&](const PassArgData &data) {
       return data.registryEntry == entry;
     });
   }
 
   /// The set of passes and pass pipelines to run.
   llvm::cl::list<PassArgData, bool, PassNameParser> passList;
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 /// Construct a pass pipeline parser with the given command line description.
 PassPipelineCLParser::PassPipelineCLParser(StringRef arg, StringRef description)
     : impl(std::make_unique<detail::PassPipelineCLParserImpl>(
           arg, description, /*passNamesOnly=*/false)) {}
 PassPipelineCLParser::~PassPipelineCLParser() {}
 
 /// Returns true if this parser contains any valid options to add.

mlir/lib/Pass/PassStatistics.cpp

constexpr StringLiteral kPassStatsDescription =
     "... Pass statistics report ...";
 
 namespace {
 /// Information pertaining to a specific statistic.
 struct Statistic {
   const char *name, *desc;
   unsigned value;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Utility to print a pass entry in the statistics output.
 static void printPassEntry(raw_ostream &os, unsigned indent, StringRef pass,
                            MutableArrayRef<Statistic> stats = llvm::None) {
   os.indent(indent) << pass << "\n";
   if (stats.empty())
     return;
 

mlir/lib/Reducer/OptReductionPass.cpp

 namespace {
 
 class OptReductionPass : public OptReductionBase<OptReductionPass> {
 public:
   /// Runs the pass instance in the pass pipeline.
   void runOnOperation() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Runs the pass instance in the pass pipeline.
 void OptReductionPass::runOnOperation() {
   LLVM_DEBUG(llvm::dbgs() << "\nOptimization Reduction pass: ");
 
   Tester test(testerName, testerArgs);
 
   ModuleOp module = this->getOperation();

mlir/lib/Reducer/ReductionTreePass.cpp

public:
   void runOnOperation() override;
 
 private:
   LogicalResult reduceOp(ModuleOp module, Region &region);
 
   FrozenRewritePatternSet reducerPatterns;
 };
 
-} // end anonymous namespace
+} // namespace
 
 LogicalResult ReductionTreePass::initialize(MLIRContext *context) {
   RewritePatternSet patterns(context);
   ReductionPatternInterfaceCollection reducePatternCollection(context);
   reducePatternCollection.populateReductionPatterns(patterns);
   reducerPatterns = std::move(patterns);
   return success();
 }

mlir/lib/Rewrite/ByteCode.h

 #ifndef MLIR_REWRITE_BYTECODE_H_
 #define MLIR_REWRITE_BYTECODE_H_
 
 #include "mlir/IR/PatternMatch.h"
 
 namespace mlir {
 namespace pdl_interp {
 class RecordMatchOp;
-} // end namespace pdl_interp
+} // namespace pdl_interp
 
 namespace detail {
 class PDLByteCode;
 
 /// Use generic bytecode types. ByteCodeField refers to the actual bytecode
 /// entries. ByteCodeAddr refers to size of indices into the bytecode.
 using ByteCodeField = uint16_t;
 using ByteCodeAddr = uint32_t;
private:
   ByteCodeField maxOpRangeCount = 0;
   ByteCodeField maxTypeRangeCount = 0;
   ByteCodeField maxValueRangeCount = 0;
 
   /// The maximum number of nested loops.
   ByteCodeField maxLoopLevel = 0;
 };
 
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 #endif // MLIR_REWRITE_BYTECODE_H_

mlir/lib/Rewrite/ByteCode.cpp

enum OpCode : ByteCodeField {
   SwitchOperationName,
   /// Compare the result count of an operation with a set of constants.
   SwitchResultCount,
   /// Compare a type with a set of constants.
   SwitchType,
   /// Compare a range of types with a set of constants.
   SwitchTypes,
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ByteCode Generation
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Generator
 
struct ByteCodeLiveRange {
   Optional<unsigned> opRangeIndex;
 
   /// The type range storage index for this range.
   Optional<unsigned> typeRangeIndex;
 
   /// The value range storage index for this range.
   Optional<unsigned> valueRangeIndex;
 };
-} // end anonymous namespace
+} // namespace
 
 void Generator::generate(ModuleOp module) {
   FuncOp matcherFunc = module.lookupSymbol<FuncOp>(
       pdl_interp::PDLInterpDialect::getMatcherFunctionName());
   ModuleOp rewriterModule = module.lookupSymbol<ModuleOp>(
       pdl_interp::PDLInterpDialect::getRewriterModuleName());
   assert(matcherFunc && rewriterModule && "invalid PDL Interpreter module");
 
MutableArrayRef<llvm::OwningArrayRef<Type>> getAllocatedTypeRanges() {
     return allocatedTypeRanges;
   }
 
   /// Return the value ranges allocated by this list.
   MutableArrayRef<llvm::OwningArrayRef<Value>> getAllocatedValueRanges() {
     return allocatedValueRanges;
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void ByteCodeExecutor::executeApplyConstraint(PatternRewriter &rewriter) {
   LLVM_DEBUG(llvm::dbgs() << "Executing ApplyConstraint:\n");
   const PDLConstraintFunction &constraintFn = constraintFunctions[read()];
   ArrayAttr constParams = read<ArrayAttr>();
   SmallVector<PDLValue, 16> args;
   readList<PDLValue>(args);
 

mlir/lib/Support/DebugCounter.cpp

llvm::cl::list<std::string> counters{
           "Comma separated list of debug counter skip and count arguments"),
       llvm::cl::CommaSeparated, llvm::cl::ZeroOrMore};
 
   llvm::cl::opt<bool> printCounterInfo{
       "mlir-print-debug-counter", llvm::cl::init(false), llvm::cl::Optional,
       llvm::cl::desc("Print out debug counter information after all counters "
                      "have been accumulated")};
 };
-} // end anonymous namespace
+} // namespace
 
 static llvm::ManagedStatic<DebugCounterOptions> clOptions;
 
 //===----------------------------------------------------------------------===//
 // DebugCounter
 //===----------------------------------------------------------------------===//
 
 DebugCounter::DebugCounter() { applyCLOptions(); }

mlir/lib/Support/StorageUniquer.cpp

 private:
   /// The main uniquer shard that is used for allocating storage instances.
   Shard shard;
 
   /// Function to used to destruct any allocated storage instances.
   function_ref<void(BaseStorage *)> destructorFn;
 #endif
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace detail {
 /// This is the implementation of the StorageUniquer class.
 struct StorageUniquerImpl {
   using BaseStorage = StorageUniquer::BaseStorage;
   using StorageAllocator = StorageUniquer::StorageAllocator;
 
struct StorageUniquerImpl {
   DenseMap<TypeID, BaseStorage *> singletonInstances;
 
   /// Allocator used for uniquing singleton instances.
   StorageAllocator singletonAllocator;
 
   /// Flag specifying if multi-threading is enabled within the uniquer.
   bool threadingIsEnabled = true;
 };
-} // end namespace detail
+} // namespace detail
 } // namespace mlir
 
 StorageUniquer::StorageUniquer() : impl(new StorageUniquerImpl()) {}
 StorageUniquer::~StorageUniquer() {}
 
 /// Set the flag specifying if multi-threading is disabled within the uniquer.
 void StorageUniquer::disableMultithreading(bool disable) {
   impl->threadingIsEnabled = !disable;

mlir/lib/Support/Timing.cpp

llvm::cl::opt<DisplayMode> displayMode{
       "mlir-timing-display", llvm::cl::desc("Display method for timing data"),
       llvm::cl::init(DisplayMode::Tree),
       llvm::cl::values(
           clEnumValN(DisplayMode::List, "list",
                      "display the results in a list sorted by total time"),
           clEnumValN(DisplayMode::Tree, "tree",
                      "display the results ina with a nested tree view"))};
 };
-} // end anonymous namespace
+} // namespace
 
 static llvm::ManagedStatic<DefaultTimingManagerOptions> options;
 
 void mlir::registerDefaultTimingManagerCLOptions() {
   // Make sure that the options struct has been constructed.
   *options;
 }
 
 void mlir::applyDefaultTimingManagerCLOptions(DefaultTimingManager &tm) {
   if (!options.isConstructed())
     return;
   tm.setEnabled(options->timing);
   tm.setDisplayMode(options->displayMode);
 }

mlir/lib/TableGen/Class.cpp

case Visibility::Public:
     return os << "public";
   case Visibility::Protected:
     return os << "protected";
   case Visibility::Private:
     return os << "private";
   }
   return os;
 }
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // ParentClass definitions
 //===----------------------------------------------------------------------===//
 
 void ParentClass::writeTo(raw_indented_ostream &os) const {
   os << visibility << ' ' << name;
   if (!templateParams.empty()) {

mlir/lib/TableGen/Predicate.cpp

struct PredNode {
   const Pred *predicate;
   SmallVector<PredNode *, 4> children;
   std::string expr;
 
   // Prefix and suffix are used by ConcatPred.
   std::string prefix;
   std::string suffix;
 };
-} // end anonymous namespace
+} // namespace
 
 // Get a predicate tree node kind based on the kind used in the predicate
 // TableGen record.
 static PredCombinerKind getPredCombinerKind(const Pred &pred) {
   if (!pred.isCombined())
     return PredCombinerKind::Leaf;
 
   const auto &combinedPred = static_cast<const CombinedPred &>(pred);
   return StringSwitch<PredCombinerKind>(
              combinedPred.getCombinerDef()->getName())
       .Case("PredCombinerAnd", PredCombinerKind::And)
       .Case("PredCombinerOr", PredCombinerKind::Or)
       .Case("PredCombinerNot", PredCombinerKind::Not)
       .Case("PredCombinerSubstLeaves", PredCombinerKind::SubstLeaves)
       .Case("PredCombinerConcat", PredCombinerKind::Concat);
 }
 
 namespace {
 // Substitution<pattern, replacement>.
 using Subst = std::pair<StringRef, StringRef>;
-} // end anonymous namespace
+} // namespace
 
 /// Perform the given substitutions on 'str' in-place.
 static void performSubstitutions(std::string &str,
                                  ArrayRef<Subst> substitutions) {
   // Apply all parent substitutions from innermost to outermost.
   for (const auto &subst : llvm::reverse(substitutions)) {
     auto pos = str.find(std::string(subst.first));
     while (pos != std::string::npos) {

mlir/lib/Target/LLVMIR/DebugTranslation.h

private:
   SmallString<256> currentWorkingDir;
 
   /// Debug information fields.
   llvm::DIBuilder builder;
   llvm::LLVMContext &llvmCtx;
   llvm::DICompileUnit *compileUnit;
 };
 
-} // end namespace detail
-} // end namespace LLVM
-} // end namespace mlir
+} // namespace detail
+} // namespace LLVM
+} // namespace mlir
 
 #endif // MLIR_LIB_TARGET_LLVMIR_DEBUGTRANSLATION_H_

mlir/lib/Target/LLVMIR/Dialect/AMX/AMXToLLVMIRTranslation.cpp

public:
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final {
     Operation &opInst = *op;
 #include "mlir/Dialect/AMX/AMXConversions.inc"
 
     return failure();
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerAMXDialectTranslation(DialectRegistry &registry) {
   registry.insert<amx::AMXDialect>();
   registry.addDialectInterface<amx::AMXDialect,
                                AMXDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerAMXDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerAMXDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/Dialect/ArmNeon/ArmNeonToLLVMIRTranslation.cpp

public:
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final {
     Operation &opInst = *op;
 #include "mlir/Dialect/ArmNeon/ArmNeonConversions.inc"
 
     return failure();
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerArmNeonDialectTranslation(DialectRegistry &registry) {
   registry.insert<arm_neon::ArmNeonDialect>();
   registry.addDialectInterface<arm_neon::ArmNeonDialect,
                                ArmNeonDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerArmNeonDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerArmNeonDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/Dialect/ArmSVE/ArmSVEToLLVMIRTranslation.cpp

public:
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final {
     Operation &opInst = *op;
 #include "mlir/Dialect/ArmSVE/ArmSVEConversions.inc"
 
     return failure();
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerArmSVEDialectTranslation(DialectRegistry &registry) {
   registry.insert<arm_sve::ArmSVEDialect>();
   registry.addDialectInterface<arm_sve::ArmSVEDialect,
                                ArmSVEDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerArmSVEDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerArmSVEDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp

public:
   /// Translates the given operation to LLVM IR using the provided IR builder
   /// and saving the state in `moduleTranslation`.
   LogicalResult
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final {
     return convertOperationImpl(*op, builder, moduleTranslation);
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerLLVMDialectTranslation(DialectRegistry &registry) {
   registry.insert<LLVM::LLVMDialect>();
   registry.addDialectInterface<LLVM::LLVMDialect,
                                LLVMDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerLLVMDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerLLVMDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/Dialect/NVVM/NVVMToLLVMIRTranslation.cpp

if (attribute.getName() == NVVM::NVVMDialect::getKernelFuncAttrName()) {
       llvm::MDNode *llvmMetadataNode =
           llvm::MDNode::get(llvmContext, llvmMetadata);
       moduleTranslation.getOrInsertNamedModuleMetadata("nvvm.annotations")
           ->addOperand(llvmMetadataNode);
     }
     return success();
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerNVVMDialectTranslation(DialectRegistry &registry) {
   registry.insert<NVVM::NVVMDialect>();
   registry.addDialectInterface<NVVM::NVVMDialect,
                                NVVMDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerNVVMDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerNVVMDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

public:
 
   /// Translates the given operation to LLVM IR using the provided IR builder
   /// and saving the state in `moduleTranslation`.
   LogicalResult
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final;
 };
 
-} // end namespace
+} // namespace
 
 /// Given an OpenACC MLIR operation, create the corresponding LLVM IR
 /// (including OpenACC runtime calls).
 LogicalResult OpenACCDialectLLVMIRTranslationInterface::convertOperation(
     Operation *op, llvm::IRBuilderBase &builder,
     LLVM::ModuleTranslation &moduleTranslation) const {
 
   return llvm::TypeSwitch<Operation *, LogicalResult>(op)

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

public:
 
   /// Translates the given operation to LLVM IR using the provided IR builder
   /// and saving the state in `moduleTranslation`.
   LogicalResult
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final;
 };
 
-} // end namespace
+} // namespace
 
 /// Given an OpenMP MLIR operation, create the corresponding LLVM IR
 /// (including OpenMP runtime calls).
 LogicalResult OpenMPDialectLLVMIRTranslationInterface::convertOperation(
     Operation *op, llvm::IRBuilderBase &builder,
     LLVM::ModuleTranslation &moduleTranslation) const {
 
   llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();

mlir/lib/Target/LLVMIR/Dialect/ROCDL/ROCDLToLLVMIRTranslation.cpp

if (attribute.getName() == ROCDL::ROCDLDialect::getKernelFuncAttrName()) {
       llvm::Function *llvmFunc =
           moduleTranslation.lookupFunction(func.getName());
       llvmFunc->setCallingConv(llvm::CallingConv::AMDGPU_KERNEL);
       llvmFunc->addFnAttr("amdgpu-flat-work-group-size", "1, 1024");
     }
     return success();
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerROCDLDialectTranslation(DialectRegistry &registry) {
   registry.insert<ROCDL::ROCDLDialect>();
   registry.addDialectInterface<ROCDL::ROCDLDialect,
                                ROCDLDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerROCDLDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerROCDLDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/Dialect/X86Vector/X86VectorToLLVMIRTranslation.cpp

public:
   convertOperation(Operation *op, llvm::IRBuilderBase &builder,
                    LLVM::ModuleTranslation &moduleTranslation) const final {
     Operation &opInst = *op;
 #include "mlir/Dialect/X86Vector/X86VectorConversions.inc"
 
     return failure();
   }
 };
-} // end namespace
+} // namespace
 
 void mlir::registerX86VectorDialectTranslation(DialectRegistry &registry) {
   registry.insert<x86vector::X86VectorDialect>();
   registry.addDialectInterface<x86vector::X86VectorDialect,
                                X86VectorDialectLLVMIRTranslationInterface>();
 }
 
 void mlir::registerX86VectorDialectTranslation(MLIRContext &context) {
   DialectRegistry registry;
   registerX86VectorDialectTranslation(registry);
   context.appendDialectRegistry(registry);
 }

mlir/lib/Target/LLVMIR/TypeFromLLVM.cpp

private:
   /// Map of known translations. Serves as a cache and as recursion stopper for
   /// translating recursive structs.
   llvm::DenseMap<llvm::Type *, Type> knownTranslations;
 
   /// The context in which MLIR types are created.
   MLIRContext &context;
 };
 
-} // end namespace detail
-} // end namespace LLVM
-} // end namespace mlir
+} // namespace detail
+} // namespace LLVM
+} // namespace mlir
 
 LLVM::TypeFromLLVMIRTranslator::TypeFromLLVMIRTranslator(MLIRContext &context)
     : impl(new detail::TypeFromLLVMIRTranslatorImpl(context)) {}
 
 LLVM::TypeFromLLVMIRTranslator::~TypeFromLLVMIRTranslator() {}
 
 Type LLVM::TypeFromLLVMIRTranslator::translateType(llvm::Type *type) {
   return impl->translateType(type);
 }

mlir/lib/Target/LLVMIR/TypeToLLVM.cpp

private:
   llvm::LLVMContext &context;
 
   /// Map of known translation. This serves a double purpose: caches translation
   /// results to avoid repeated recursive calls and makes sure identified
   /// structs with the same name (that is, equal) are resolved to an existing
   /// type instead of creating a new type.
   llvm::DenseMap<Type, llvm::Type *> knownTranslations;
 };
-} // end namespace detail
-} // end namespace LLVM
-} // end namespace mlir
+} // namespace detail
+} // namespace LLVM
+} // namespace mlir
 
 LLVM::TypeToLLVMIRTranslator::TypeToLLVMIRTranslator(llvm::LLVMContext &context)
     : impl(new detail::TypeToLLVMIRTranslatorImpl(context)) {}
 
 LLVM::TypeToLLVMIRTranslator::~TypeToLLVMIRTranslator() {}
 
 llvm::Type *LLVM::TypeToLLVMIRTranslator::translateType(Type type) {
   return impl->translateType(type);
 }
 
 unsigned LLVM::TypeToLLVMIRTranslator::getPreferredAlignment(
     Type type, const llvm::DataLayout &layout) {
   return layout.getPrefTypeAlignment(translateType(type));
 }

mlir/lib/Transforms/BufferOptimizations.cpp

void runOnFunction() override {
     BufferPlacementPromotion optimizer(getFunction());
     optimizer.promote(isSmallAlloc);
   }
 
 private:
   std::function<bool(Value)> isSmallAlloc;
 };
 
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::createBufferHoistingPass() {
   return std::make_unique<BufferHoistingPass>();
 }
 
 std::unique_ptr<Pass> mlir::createBufferLoopHoistingPass() {
   return std::make_unique<BufferLoopHoistingPass>();
 }

mlir/lib/Transforms/BufferResultsToOutParams.cpp

for (auto func : module.getOps<FuncOp>()) {
       if (func.isExternal())
         continue;
       updateReturnOps(func, appendedEntryArgs);
     }
     if (failed(updateCalls(module)))
       return signalPassFailure();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::createBufferResultsToOutParamsPass() {
   return std::make_unique<BufferResultsToOutParamsPass>();
 }

mlir/lib/Transforms/CSE.cpp

if (lhs == getTombstoneKey() || lhs == getEmptyKey() ||
       return false;
     return OperationEquivalence::isEquivalentTo(
         const_cast<Operation *>(lhsC), const_cast<Operation *>(rhsC),
         /*mapOperands=*/OperationEquivalence::exactValueMatch,
         /*mapResults=*/OperationEquivalence::ignoreValueEquivalence,
         OperationEquivalence::IgnoreLocations);
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace {
 /// Simple common sub-expression elimination.
 struct CSE : public CSEBase<CSE> {
   /// Shared implementation of operation elimination and scoped map definitions.
   using AllocatorTy = llvm::RecyclingAllocator<
       llvm::BumpPtrAllocator,
       llvm::ScopedHashTableVal<Operation *, Operation *>>;
struct CSE : public CSEBase<CSE> {
 
   void runOnOperation() override;
 
 private:
   /// Operations marked as dead and to be erased.
   std::vector<Operation *> opsToErase;
   DominanceInfo *domInfo = nullptr;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Attempt to eliminate a redundant operation.
 LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op,
                                      bool hasSSADominance) {
   // Don't simplify terminator operations.
   if (op->hasTrait<OpTrait::IsTerminator>())
     return failure();
 

mlir/lib/Transforms/Canonicalizer.cpp

struct Canonicalizer : public CanonicalizerBase<Canonicalizer> {
   void runOnOperation() override {
     (void)applyPatternsAndFoldGreedily(getOperation()->getRegions(), patterns,
                                        config);
   }
 
   GreedyRewriteConfig config;
   FrozenRewritePatternSet patterns;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Create a Canonicalizer pass.
 std::unique_ptr<Pass> mlir::createCanonicalizerPass() {
   return std::make_unique<Canonicalizer>();
 }
 
 /// Creates an instance of the Canonicalizer pass with the specified config.
 std::unique_ptr<Pass>
 mlir::createCanonicalizerPass(const GreedyRewriteConfig &config) {
   return std::make_unique<Canonicalizer>(config);
 }

mlir/lib/Transforms/Inliner.cpp

private:
 
   /// A mapping between a callgraph node and the symbol callgraph nodes that it
   /// uses.
   DenseMap<CallGraphNode *, CGUser> nodeUses;
 
   /// A symbol table to use when resolving call lookups.
   SymbolTableCollection &symbolTable;
 };
-} // end anonymous namespace
+} // namespace
 
 CGUseList::CGUseList(Operation *op, CallGraph &cg,
                      SymbolTableCollection &symbolTable)
     : symbolTable(symbolTable) {
   /// A set of callgraph nodes that are always known to be live during inlining.
   DenseMap<Attribute, CallGraphNode *> alwaysLiveNodes;
 
   // Walk each of the symbol tables looking for discardable callgraph nodes.
if (it != nodes.end()) {
       parentIterator.ReplaceNode(node, nullptr);
     }
   }
 
 private:
   std::vector<CallGraphNode *> nodes;
   llvm::scc_iterator<const CallGraph *> &parentIterator;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Run a given transformation over the SCCs of the callgraph in a bottom up
 /// traversal.
 static LogicalResult runTransformOnCGSCCs(
     const CallGraph &cg,
     function_ref<LogicalResult(CallGraphSCC &)> sccTransformer) {
   llvm::scc_iterator<const CallGraph *> cgi = llvm::scc_begin(&cg);
   CallGraphSCC currentSCC(cgi);

 /// explicitly.
 struct ResolvedCall {
   ResolvedCall(CallOpInterface call, CallGraphNode *sourceNode,
                CallGraphNode *targetNode)
       : call(call), sourceNode(sourceNode), targetNode(targetNode) {}
   CallOpInterface call;
   CallGraphNode *sourceNode, *targetNode;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Collect all of the callable operations within the given range of blocks. If
 /// `traverseNestedCGNodes` is true, this will also collect call operations
 /// inside of nested callgraph nodes.
 static void collectCallOps(iterator_range<Region::iterator> blocks,
                            CallGraphNode *sourceNode, CallGraph &cg,
                            SymbolTableCollection &symbolTable,
                            SmallVectorImpl<ResolvedCall> &calls,
private:
   /// a given operation.
   std::function<void(OpPassManager &)> defaultPipeline;
   /// A map of operation names to pass pipelines to use when optimizing
   /// callable operations of these types. This provides a specialized pipeline
   /// instead of the default. The vector size is the number of threads used
   /// during optimization.
   SmallVector<llvm::StringMap<OpPassManager>, 8> opPipelines;
 };
-} // end anonymous namespace
+} // namespace
 
 InlinerPass::InlinerPass() : InlinerPass(defaultInlinerOptPipeline) {}
 InlinerPass::InlinerPass(std::function<void(OpPassManager &)> defaultPipeline)
     : defaultPipeline(defaultPipeline) {
   opPipelines.push_back({});
 
   // Initialize the pass options with the provided arguments.
   if (defaultPipeline) {

mlir/lib/Transforms/LocationSnapshot.cpp

void runOnOperation() override {
     Operation *op = getOperation();
     if (failed(generateLocationsFromIR(fileName, op, OpPrintingFlags(), tag)))
       return signalPassFailure();
   }
 
   /// The printing flags to use when creating the snapshot.
   OpPrintingFlags flags;
 };
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<Pass> mlir::createLocationSnapshotPass(OpPrintingFlags flags,
                                                        StringRef fileName,
                                                        StringRef tag) {
   return std::make_unique<LocationSnapshotPass>(flags, fileName, tag);
 }
 std::unique_ptr<Pass> mlir::createLocationSnapshotPass() {
   return std::make_unique<LocationSnapshotPass>();
 }

mlir/lib/Transforms/LoopFusion.cpp

LoopFusion(unsigned fastMemorySpace, uint64_t localBufSizeThresholdBytes,
     this->localBufSizeThreshold = localBufSizeThresholdBytes / 1024;
     this->maximalFusion = maximalFusion;
     this->affineFusionMode = affineFusionMode;
   }
 
   void runOnFunction() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::createLoopFusionPass(unsigned fastMemorySpace,
                            uint64_t localBufSizeThreshold, bool maximalFusion,
                            enum FusionMode affineFusionMode) {
   return std::make_unique<LoopFusion>(fastMemorySpace, localBufSizeThreshold,
                                       maximalFusion, affineFusionMode);
 }
for (auto *storeOpInst : node->stores) {
     // Check if 'memref' escapes through a non-affine op (e.g., std load/store,
     // call op, etc.).
     for (Operation *user : memref.getUsers())
       if (!isa<AffineMapAccessInterface>(*user))
         escapingMemRefs.insert(memref);
   }
 }
 
-} // end anonymous namespace
+} // namespace
 
 // Initializes the data dependence graph by walking operations in 'f'.
 // Assigns each node in the graph a node id based on program order in 'f'.
 // TODO: Add support for taking a Block arg to construct the
 // dependence graph at a different depth.
 bool MemRefDependenceGraph::init(FuncOp f) {
   LLVM_DEBUG(llvm::dbgs() << "--- Initializing MDG ---\n");
   DenseMap<Value, SetVector<unsigned>> memrefAccesses;
for (auto &pair : mdg->memrefEdgeCount) {
       // Use list expected to match the dep graph info.
       auto *op = memref.getDefiningOp();
       if (isa_and_nonnull<memref::AllocOp>(op))
         op->erase();
     }
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 void LoopFusion::runOnFunction() {
   MemRefDependenceGraph g;
   if (!g.init(getFunction()))
     return;
 
   Optional<unsigned> fastMemorySpaceOpt;
   if (fastMemorySpace.hasValue())

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

 using namespace mlir;
 
 namespace {
 /// Loop invariant code motion (LICM) pass.
 struct LoopInvariantCodeMotion
     : public LoopInvariantCodeMotionBase<LoopInvariantCodeMotion> {
   void runOnOperation() override;
 };
-} // end anonymous namespace
+} // namespace
 
 // Checks whether the given op can be hoisted by checking that
 // - the op and any of its contained operations do not depend on SSA values
 //   defined inside of the loop (by means of calling definedOutside).
 // - the op has no side-effects. If sideEffecting is Never, sideeffects of this
 //   op and its nested ops are ignored.
 static bool canBeHoisted(Operation *op,
                          function_ref<bool(Value)> definedOutside) {

mlir/lib/Transforms/NormalizeMemRefs.cpp

struct NormalizeMemRefs : public NormalizeMemRefsBase<NormalizeMemRefs> {
   void normalizeFuncOpMemRefs(FuncOp funcOp, ModuleOp moduleOp);
   bool areMemRefsNormalizable(FuncOp funcOp);
   void updateFunctionSignature(FuncOp funcOp, ModuleOp moduleOp);
   void setCalleesAndCallersNonNormalizable(FuncOp funcOp, ModuleOp moduleOp,
                                            DenseSet<FuncOp> &normalizableFuncs);
   Operation *createOpResultsNormalized(FuncOp funcOp, Operation *oldOp);
 };
 
-} // end anonymous namespace
+} // namespace
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createNormalizeMemRefsPass() {
   return std::make_unique<NormalizeMemRefs>();
 }
 
 void NormalizeMemRefs::runOnOperation() {
   LLVM_DEBUG(llvm::dbgs() << "Normalizing Memrefs...\n");
   ModuleOp moduleOp = getOperation();

mlir/lib/Transforms/PassDetail.h

 class AffineDialect;
 
 // Forward declaration from Dialect.h
 template <typename ConcreteDialect>
 void registerDialect(DialectRegistry &registry);
 
 namespace arith {
 class ArithmeticDialect;
-} // end namespace arith
+} // namespace arith
 
 namespace memref {
 class MemRefDialect;
-} // end namespace memref
+} // namespace memref
 
 namespace bufferization {
 class BufferizationDialect;
 } // namespace bufferization
 
 #define GEN_PASS_CLASSES
 #include "mlir/Transforms/Passes.h.inc"
 
-} // end namespace mlir
+} // namespace mlir
 
 #endif // TRANSFORMS_PASSDETAIL_H_

mlir/lib/Transforms/PipelineDataTransfer.cpp

 struct PipelineDataTransfer
     : public AffinePipelineDataTransferBase<PipelineDataTransfer> {
   void runOnFunction() override;
   void runOnAffineForOp(AffineForOp forOp);
 
   std::vector<AffineForOp> forOps;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Creates a pass to pipeline explicit movement of data across levels of the
 /// memory hierarchy.
 std::unique_ptr<OperationPass<FuncOp>> mlir::createPipelineDataTransferPass() {
   return std::make_unique<PipelineDataTransfer>();
 }
 
 // Returns the position of the tag memref operand given a DMA operation.

mlir/lib/Transforms/SCCP.cpp

 //===----------------------------------------------------------------------===//
 // SCCP Pass
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct SCCP : public SCCPBase<SCCP> {
   void runOnOperation() override;
 };
-} // end anonymous namespace
+} // namespace
 
 void SCCP::runOnOperation() {
   Operation *op = getOperation();
 
   SCCPAnalysis analysis(op->getContext());
   analysis.run(op);
   rewrite(analysis, op->getContext(), op->getRegions());
 }
 
 std::unique_ptr<Pass> mlir::createSCCPPass() {
   return std::make_unique<SCCP>();
 }

mlir/lib/Transforms/StripDebugInfo.cpp

 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
 struct StripDebugInfo : public StripDebugInfoBase<StripDebugInfo> {
   void runOnOperation() override;
 };
-} // end anonymous namespace
+} // namespace
 
 void StripDebugInfo::runOnOperation() {
   auto unknownLoc = UnknownLoc::get(&getContext());
 
   // Strip the debug info from all operations.
   getOperation()->walk([&](Operation *op) {
     op->setLoc(unknownLoc);
     // Strip block arguments debug info.

mlir/lib/Transforms/SymbolDCE.cpp

struct SymbolDCE : public SymbolDCEBase<SymbolDCE> {
   /// Compute the liveness of the symbols within the given symbol table.
   /// `symbolTableIsHidden` is true if this symbol table is known to be
   /// unaccessible from operations in its parent regions.
   LogicalResult computeLiveness(Operation *symbolTableOp,
                                 SymbolTableCollection &symbolTable,
                                 bool symbolTableIsHidden,
                                 DenseSet<Operation *> &liveSymbols);
 };
-} // end anonymous namespace
+} // namespace
 
 void SymbolDCE::runOnOperation() {
   Operation *symbolTableOp = getOperation();
 
   // SymbolDCE should only be run on operations that define a symbol table.
   if (!symbolTableOp->hasTrait<OpTrait::SymbolTable>()) {
     symbolTableOp->emitOpError()
         << " was scheduled to run under SymbolDCE, but does not define a "

mlir/lib/Transforms/Utils/DialectConversion.cpp

for (auto &it : mapping.getValueMap())
       inverse[it.second].push_back(it.first);
     return inverse;
   }
 
 private:
   /// Current value mappings.
   BlockAndValueMapping mapping;
 };
-} // end anonymous namespace
+} // namespace
 
 Value ConversionValueMapping::lookupOrDefault(Value from,
                                               Type desiredType) const {
   // If there was no desired type, simply find the leaf value.
   if (!desiredType) {
     // If this value had a valid mapping, unmap that value as well in the case
     // that it was also replaced.
     while (auto mappedValue = mapping.lookupOrNull(from))
private:
 
   /// The corresponding type converter to use when resolving this
   /// materialization, and the kind of this materialization.
   llvm::PointerIntPair<TypeConverter *, 1, Kind> converterAndKind;
 
   /// The original output type. This is only used for argument conversions.
   Type origOutputType;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Build an unresolved materialization operation given an output type and set
 /// of input operands.
 static Value buildUnresolvedMaterialization(
     UnresolvedMaterialization::Kind kind, Block *insertBlock,
     Block::iterator insertPt, Location loc, ValueRange inputs, Type outputType,
     Type origOutputType, TypeConverter *converter,
     SmallVectorImpl<UnresolvedMaterialization> &unresolvedMaterializations) {
struct ArgConverter {
   DenseMap<Region *, TypeConverter *> regionToConverter;
 
   /// The pattern rewriter to use when materializing conversions.
   PatternRewriter &rewriter;
 
   /// An ordered set of unresolved materializations during conversion.
   SmallVectorImpl<UnresolvedMaterialization> &unresolvedMaterializations;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Rewrite Application
 
 void ArgConverter::notifyOpRemoved(Operation *op) {
   if (conversionInfo.empty())
     return;
 
#ifndef NDEBUG
   /// strictly necessary, and is thus only active during debug builds for extra
   /// verification.
   SmallPtrSet<Operation *, 1> pendingRootUpdates;
 
   /// A logger used to emit diagnostics during the conversion process.
   llvm::ScopedPrinter logger{llvm::dbgs()};
 #endif
 };
-} // end namespace detail
-} // end namespace mlir
+} // namespace detail
+} // namespace mlir
 
 /// Detach any operations nested in the given operation from their parent
 /// blocks, and erase the given operation. This can be used when the nested
 /// operations are scheduled for erasure themselves, so deleting the regions of
 /// the given operation together with their content would result in double-free.
 /// This happens, for example, when rolling back op creation in the reverse
 /// order and if the nested ops were created before the parent op. This function
 /// does not need to collect nested ops recursively because it is expected to
private:
   OpConversionMode mode;
 
   /// A set of pre-existing operations. When mode == OpConversionMode::Analysis,
   /// this is populated with ops found to be legalizable to the target.
   /// When mode == OpConversionMode::Partial, this is populated with ops found
   /// *not* to be legalizable to the target.
   DenseSet<Operation *> *trackedOps;
 };
-} // end anonymous namespace
+} // namespace
 
 LogicalResult OperationConverter::convert(ConversionPatternRewriter &rewriter,
                                           Operation *op) {
   // Legalize the given operation.
   if (failed(opLegalizer.legalize(op, rewriter))) {
     // Handle the case of a failed conversion for each of the different modes.
     // Full conversions expect all operations to be converted.
     if (mode == OpConversionMode::Full)
auto newType = FunctionType::get(rewriter.getContext(),
                                      result.getConvertedTypes(), newResults);
 
     rewriter.updateRootInPlace(
         op, [&] { function_like_impl::setFunctionType(op, newType); });
 
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void mlir::populateFunctionLikeTypeConversionPattern(
     StringRef functionLikeOpName, RewritePatternSet &patterns,
     TypeConverter &converter) {
   patterns.add<FunctionLikeSignatureConversion>(
       functionLikeOpName, patterns.getContext(), converter);
 }
 

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

private:
   /// Configuration information for how to simplify.
   GreedyRewriteConfig config;
 
 #ifndef NDEBUG
   /// A logger used to emit information during the application process.
   llvm::ScopedPrinter logger{llvm::dbgs()};
 #endif
 };
-} // end anonymous namespace
+} // namespace
 
 GreedyPatternRewriteDriver::GreedyPatternRewriteDriver(
     MLIRContext *ctx, const FrozenRewritePatternSet &patterns,
     const GreedyRewriteConfig &config)
     : PatternRewriter(ctx), matcher(patterns), folder(ctx), config(config) {
   worklist.reserve(64);
 
   // Apply a simple cost model based solely on pattern benefit.
private:
 
   /// Non-pattern based folder for operations.
   OperationFolder folder;
 
   /// Set to true if the operation has been erased via pattern rewrites.
   bool opErasedViaPatternRewrites = false;
 };
 
-} // anonymous namespace
+} // namespace
 
 /// Performs the rewrites and folding only on `op`. The simplification
 /// converges if the op is erased as a result of being folded, replaced, or
 /// becoming dead, or no more changes happen in an iteration. Returns success if
 /// the rewrite converges in `maxIterations`. `erased` is set to true if `op`
 /// gets erased.
 LogicalResult OpPatternRewriteDriver::simplifyLocally(Operation *op,
                                                       int maxIterations,
private:
   bool strictMode = false;
 
   /// The list of ops we are restricting our rewrites to if `strictMode` is on.
   /// These include the supplied set of ops as well as new ops created while
   /// rewriting those ops. This set is not maintained when strictMode is off.
   llvm::SmallDenseSet<Operation *, 4> strictModeFilteredOps;
 };
 
-} // end anonymous namespace
+} // namespace
 
 /// Performs the specified rewrites on `ops` while also trying to fold these ops
 /// as well as any other ops that were in turn created due to these rewrite
 /// patterns. Any pre-existing ops outside of `ops` remain completely
 /// unmodified if `strictMode` is true. If `strictMode` is false, other
 /// operations that use results of rewritten ops or supply operands to such ops
 /// are in turn simplified; any other ops still remain unmodified (i.e.,
 /// regardless of `strictMode`). Note that ops in `ops` could be erased as a

mlir/lib/Transforms/Utils/RegionUtils.cpp

struct BlockEquivalenceData {
   Block *block;
   /// A hash value for this block.
   llvm::hash_code hash;
   /// A map of result producing operations to their relative orders within this
   /// block. The order of an operation is the number of defined values that are
   /// produced within the block before this operation.
   DenseMap<Operation *, unsigned> opOrderIndex;
 };
-} // end anonymous namespace
+} // namespace
 
 BlockEquivalenceData::BlockEquivalenceData(Block *block)
     : block(block), hash(0) {
   unsigned orderIt = block->getNumArguments();
   for (Operation &op : *block) {
     if (unsigned numResults = op.getNumResults()) {
       opOrderIndex.try_emplace(&op, orderIt);
       orderIt += numResults;
private:
 
   /// The set of blocks that can be merged into the leader.
   llvm::SmallSetVector<Block *, 1> blocksToMerge;
 
   /// A set of operand+index pairs that correspond to operands that need to be
   /// replaced by arguments when the cluster gets merged.
   std::set<std::pair<int, int>> operandsToMerge;
 };
-} // end anonymous namespace
+} // namespace
 
 LogicalResult BlockMergeCluster::addToCluster(BlockEquivalenceData &blockData) {
   if (leaderData.hash != blockData.hash)
     return failure();
   Block *leaderBlock = leaderData.block, *mergeBlock = blockData.block;
   if (leaderBlock->getArgumentTypes() != mergeBlock->getArgumentTypes())
     return failure();
 

mlir/test/APITest.h

 
 // Test registration class.  Used internally by test macros to register tests
 // during static allocation.
 struct TestRegistration {
   explicit TestRegistration(std::function<void()> func) {
     test_detail::tests().push_back(func);
   }
 };
-} // end namespace test_detail
+} // namespace test_detail
 
 /// Declares a test function with the given name and adds it to the list of
 /// known tests.  The body of the function must follow immediately.  Example:
 ///
 /// TEST_FUNC(mytest) {
 ///   // CHECK: expected-output-here
 ///   emitSomethingToStdOut();
 /// }

mlir/test/lib/Analysis/TestAliasAnalysis.cpp

struct TestAliasAnalysisPass
   /// Print the result of an alias query.
   void printAliasResult(AliasResult result, Value lhs, Value rhs) {
     printAliasOperand(lhs);
     llvm::errs() << " <-> ";
     printAliasOperand(rhs);
     llvm::errs() << ": " << result << "\n";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Testing ModRefResult
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TestAliasAnalysisModRefPass
     : public PassWrapper<TestAliasAnalysisModRefPass, OperationPass<>> {
struct TestAliasAnalysisModRefPass
   /// Print the result of an alias query.
   void printModRefResult(ModRefResult result, Operation *op, Value location) {
     printAliasOperand(op);
     llvm::errs() << " -> ";
     printAliasOperand(location);
     llvm::errs() << ": " << result << "\n";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Pass Registration
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace test {
 void registerTestAliasAnalysisPass() {
   PassRegistration<TestAliasAnalysisPass>();
   PassRegistration<TestAliasAnalysisModRefPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestCallGraph.cpp

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

mlir/test/lib/Analysis/TestLiveness.cpp

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

mlir/test/lib/Analysis/TestMatchReduction.cpp

func.walk<WalkOrder::PreOrder>([](Operation *op) {
         SmallVector<Operation *, 4> combinerOps;
         Value reducedValue = matchReduction(outputs, i, combinerOps);
         printReductionResult(op, i, reducedValue, combinerOps);
       }
     });
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestMatchReductionPass() {
   PassRegistration<TestMatchReductionPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMemRefBoundCheck.cpp

struct TestMemRefBoundCheck
     : public PassWrapper<TestMemRefBoundCheck, FunctionPass> {
   StringRef getArgument() const final { return "test-memref-bound-check"; }
   StringRef getDescription() const final {
     return "Check memref access bounds in a Function";
   }
   void runOnFunction() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 void TestMemRefBoundCheck::runOnFunction() {
   getFunction().walk([](Operation *opInst) {
     TypeSwitch<Operation *>(opInst)
         .Case<AffineReadOpInterface, AffineWriteOpInterface>(
             [](auto op) { (void)boundCheckLoadOrStoreOp(op); });
 
     // TODO: do this for DMA ops as well.
   });
 }
 
 namespace mlir {
 namespace test {
 void registerMemRefBoundCheck() { PassRegistration<TestMemRefBoundCheck>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp

struct TestMemRefDependenceCheck
   StringRef getArgument() const final { return "test-memref-dependence-check"; }
   StringRef getDescription() const final {
     return "Checks dependences between all pairs of memref accesses.";
   }
   SmallVector<Operation *, 4> loadsAndStores;
   void runOnFunction() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 // Returns a result string which represents the direction vector (if there was
 // a dependence), returns the string "false" otherwise.
 static std::string
 getDirectionVectorStr(bool ret, unsigned numCommonLoops, unsigned loopNestDepth,
                       ArrayRef<DependenceComponent> dependenceComponents) {
   if (!ret)
     return "false";

mlir/test/lib/Analysis/TestMemRefStrideCalculation.cpp

struct TestMemRefStrideCalculation
   StringRef getArgument() const final {
     return "test-memref-stride-calculation";
   }
   StringRef getDescription() const final {
     return "Test operation constant folding";
   }
   void runOnFunction() override;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Traverse AllocOp and compute strides of each MemRefType independently.
 void TestMemRefStrideCalculation::runOnFunction() {
   llvm::outs() << "Testing: " << getFunction().getName() << "\n";
   getFunction().walk([&](memref::AllocOp allocOp) {
     auto memrefType = allocOp.getResult().getType().cast<MemRefType>();
     int64_t offset;
     SmallVector<int64_t, 4> strides;

mlir/test/lib/Analysis/TestNumberOfExecutions.cpp

struct TestNumberOfOperationExecutionsPass
   }
   void runOnFunction() override {
     llvm::errs() << "Number of executions: " << getFunction().getName() << "\n";
     getAnalysis<NumberOfExecutions>().printOperationExecutions(
         llvm::errs(), &getFunction().getBody());
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestNumberOfBlockExecutionsPass() {
   PassRegistration<TestNumberOfBlockExecutionsPass>();
 }
 
 void registerTestNumberOfOperationExecutionsPass() {
   PassRegistration<TestNumberOfOperationExecutionsPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Analysis/TestSlice.cpp

void runOnFunction() override {
     llvm::errs() << "Testing : " << getFunction().getName() << "\n";
     for (Operation *op : sortedOp) {
       op->print(llvm::errs());
       llvm::errs() << "\n";
     }
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestSliceAnalysisPass() {
   PassRegistration<TestTopologicalSortPass>();
 }
 } // namespace test
 } // namespace mlir

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

Option<bool> clMemRefFilter{
           "Enable memref filter testing in affine data copy optimization"),
       llvm::cl::init(false)};
   Option<bool> clTestGenerateCopyForMemRegion{
       *this, "for-memref-region",
       llvm::cl::desc("Test copy generation for a single memref region"),
       llvm::cl::init(false)};
 };
 
-} // end anonymous namespace
+} // namespace
 
 void TestAffineDataCopy::runOnFunction() {
   // Gather all AffineForOps by loop depth.
   std::vector<SmallVector<AffineForOp, 2>> depthToLoops;
   gatherLoops(getFunction(), depthToLoops);
   assert(depthToLoops.size() && "Loop nest not found");
 
   // Only support tests with a single loop nest and a single innermost loop

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

 struct TestAffineLoopParametricTiling
     : public PassWrapper<TestAffineLoopParametricTiling, FunctionPass> {
   StringRef getArgument() const final { return "test-affine-parametric-tile"; }
   StringRef getDescription() const final {
     return "Tile affine loops using SSA values as tile sizes";
   }
   void runOnFunction() override;
 };
-} // end anonymous namespace
+} // namespace
 
 /// Checks if the function enclosing the loop nest has any arguments passed to
 /// it, which can be used as tiling parameters. Assumes that atleast 'n'
 /// arguments are passed, where 'n' is the number of loops in the loop nest.
 static void checkIfTilingParametersExist(ArrayRef<AffineForOp> band) {
   assert(!band.empty() && "no loops in input band");
   AffineForOp topLoop = band[0];
 

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

struct TestAffineLoopUnswitching
   TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass) {}
 
   void runOnFunction() override;
 
   /// The maximum number of iterations to run this for.
   constexpr static unsigned kMaxIterations = 5;
 };
 
-} // end anonymous namespace
+} // namespace
 
 void TestAffineLoopUnswitching::runOnFunction() {
   // Each hoisting invalidates a lot of IR around. Just stop the walk after the
   // first if/else hoisting, and repeat until no more hoisting can be done, or
   // the maximum number of iterations have been run.
   auto func = getFunction();
   unsigned i = 0;
   do {

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

 private:
   /// Permutation specifying loop i is mapped to permList[i] in
   /// transformed nest (with i going from outermost to innermost).
   ListOption<unsigned> permList{*this, "permutation-map",
                                 llvm::cl::desc("Specify the loop permutation"),
                                 llvm::cl::OneOrMore, llvm::cl::CommaSeparated};
 };
 
-} // end anonymous namespace
+} // namespace
 
 void TestLoopPermutation::runOnFunction() {
 
   SmallVector<unsigned, 4> permMap(permList.begin(), permList.end());
 
   SmallVector<AffineForOp, 2> forOps;
   getFunction().walk([&](AffineForOp forOp) { forOps.push_back(forOp); });
 

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

struct VectorizerTestPass
   void testBackwardSlicing(llvm::raw_ostream &outs);
   void testSlicing(llvm::raw_ostream &outs);
   void testComposeMaps(llvm::raw_ostream &outs);
 
   /// Test for 'vectorizeAffineLoopNest' utility.
   void testVecAffineLoopNest();
 };
 
-} // end anonymous namespace
+} // namespace
 
 void VectorizerTestPass::testVectorShapeRatio(llvm::raw_ostream &outs) {
   auto f = getFunction();
   using matcher::Op;
   SmallVector<int64_t, 8> shape(clTestVectorShapeRatio.begin(),
                                 clTestVectorShapeRatio.end());
   auto subVectorType =
       VectorType::get(shape, FloatType::getF32(f.getContext()));

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

class TestGpuMemoryPromotionPass
   void runOnOperation() override {
     gpu::GPUFuncOp op = getOperation();
     for (unsigned i = 0, e = op.getNumArguments(); i < e; ++i) {
       if (op.getArgAttrOfType<UnitAttr>(i, "gpu.test_promote_workgroup"))
         promoteToWorkgroupMemory(op, i);
     }
   }
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
 void registerTestGpuMemoryPromotionPass() {
   PassRegistration<TestGpuMemoryPromotionPass>();
 }
 } // namespace mlir

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

strategy
               .enableTransferToSCFConversion());
   // Created a nested OpPassManager and run.
   FuncOp funcOp = getFunction();
   OpPassManager dynamicPM("builtin.func");
   strategy.configurePassPipeline(dynamicPM, funcOp.getContext(), runEnablePass);
   if (failed(runPipeline(dynamicPM, funcOp)))
     return signalPassFailure();
 }
-} // end anonymous namespace
+} // namespace
 
 // For now, just assume it is the zero of type.
 // In the future, it should be the zero of type + op.
 static Value getNeutralOfLinalgOp(OpBuilder &b, OpOperand &op) {
   auto t = getElementTypeOrSelf(op.get());
   return b.create<arith::ConstantOp>(op.getOwner()->getLoc(), t,
                                      b.getZeroAttr(t));
 }

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

struct TestLinalgHoisting
 
   void runOnFunction() override;
 
   Option<bool> testHoistRedundantTransfers{
       *this, "test-hoist-redundant-transfers",
       llvm::cl::desc("Test hoisting transfer_read/transfer_write pairs"),
       llvm::cl::init(false)};
 };
-} // end anonymous namespace
+} // namespace
 
 void TestLinalgHoisting::runOnFunction() {
   if (testHoistRedundantTransfers) {
     hoistRedundantVectorTransfers(getFunction());
     hoistRedundantVectorTransfersOnTensor(getFunction());
     return;
   }
 }
 
 namespace mlir {
 namespace test {
 void registerTestLinalgHoisting() { PassRegistration<TestLinalgHoisting>(); }
 } // namespace test
 } // namespace mlir

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

Option<bool> skipPartial{
       llvm::cl::desc("Skip loops inside partial iterations during peeling"),
       llvm::cl::init(false)};
   Option<std::string> loopType{
       *this, "loop-type",
       llvm::cl::desc("Specify the type of loops to generate: for, parallel or "
                      "tiled_loop"),
       llvm::cl::init("for")};
 };
-} // end anonymous namespace
+} // namespace
 
 static void applyPatterns(FuncOp funcOp) {
   MLIRContext *ctx = funcOp.getContext();
   RewritePatternSet patterns(ctx);
 
   //===--------------------------------------------------------------------===//
   // Linalg tiling patterns.
   //===--------------------------------------------------------------------===//

mlir/test/lib/Dialect/Math/TestAlgebraicSimplification.cpp

struct TestMathAlgebraicSimplificationPass
   }
   StringRef getArgument() const final {
     return "test-math-algebraic-simplification";
   }
   StringRef getDescription() const final {
     return "Test math algebraic simplification";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void TestMathAlgebraicSimplificationPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
   populateMathAlgebraicSimplificationPatterns(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestMathAlgebraicSimplificationPass() {
   PassRegistration<TestMathAlgebraicSimplificationPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Math/TestExpandTanh.cpp

 
 namespace {
 struct TestExpandTanhPass
     : public PassWrapper<TestExpandTanhPass, FunctionPass> {
   void runOnFunction() override;
   StringRef getArgument() const final { return "test-expand-tanh"; }
   StringRef getDescription() const final { return "Test expanding tanh"; }
 };
-} // end anonymous namespace
+} // namespace
 
 void TestExpandTanhPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
   populateExpandTanhPattern(patterns);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestExpandTanhPass() { PassRegistration<TestExpandTanhPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Math/TestPolynomialApproximation.cpp

struct TestMathPolynomialApproximationPass
   }
 
   Option<bool> enableAvx2{
       *this, "enable-avx2",
       llvm::cl::desc("Enable approximations that emit AVX2 intrinsics via the "
                      "X86Vector dialect"),
       llvm::cl::init(false)};
 };
-} // end anonymous namespace
+} // namespace
 
 void TestMathPolynomialApproximationPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
   MathPolynomialApproximationOptions approx_options;
   approx_options.enableAvx2 = enableAvx2;
   populateMathPolynomialApproximationPatterns(patterns, approx_options);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestMathPolynomialApproximationPass() {
   PassRegistration<TestMathPolynomialApproximationPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

 struct PrintOpAvailability
     : public PassWrapper<PrintOpAvailability, FunctionPass> {
   void runOnFunction() override;
   StringRef getArgument() const final { return "test-spirv-op-availability"; }
   StringRef getDescription() const final {
     return "Test SPIR-V op availability";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void PrintOpAvailability::runOnFunction() {
   auto f = getFunction();
   llvm::outs() << f.getName() << "\n";
 
   Dialect *spvDialect = getContext().getLoadedDialect("spv");
 
   f->walk([&](Operation *op) {
LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override;
 };
 
 struct ConvertToSubgroupBallot : public RewritePattern {
   ConvertToSubgroupBallot(MLIRContext *context);
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override;
 };
-} // end anonymous namespace
+} // namespace
 
 void ConvertToTargetEnv::runOnFunction() {
   MLIRContext *context = &getContext();
   FuncOp fn = getFunction();
 
   auto targetEnv = fn.getOperation()
                        ->getAttr(spirv::getTargetEnvAttrName())
                        .cast<spirv::TargetEnvAttr>();

mlir/test/lib/Dialect/Shape/TestShapeFunctions.cpp

 struct ReportShapeFnPass
     : public PassWrapper<ReportShapeFnPass, OperationPass<ModuleOp>> {
   void runOnOperation() override;
   StringRef getArgument() const final { return "test-shape-function-report"; }
   StringRef getDescription() const final {
     return "Test pass to report associated shape functions";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void ReportShapeFnPass::runOnOperation() {
   auto module = getOperation();
 
   // Report the shape function available to refine the op.
   auto shapeFnId = StringAttr::get(&getContext(), "shape.function");
   auto remarkShapeFn = [&](shape::FunctionLibraryOp shapeFnLib, Operation *op) {
     if (op->hasTrait<OpTrait::IsTerminator>())

mlir/test/lib/Dialect/StandardOps/TestDecomposeCallGraphTypes.cpp

void runOnOperation() override {
     populateDecomposeCallGraphTypesPatterns(context, typeConverter, decomposer,
                                             patterns);
 
     if (failed(applyPartialConversion(module, target, std::move(patterns))))
       return signalPassFailure();
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestDecomposeCallGraphTypes() {
   PassRegistration<TestDecomposeCallGraphTypes>();
 }
 } // namespace test
 } // namespace mlir

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

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

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

public:
   TestReductionPatternInterface(Dialect *dialect)
       : DialectReductionPatternInterface(dialect) {}
 
   void populateReductionPatterns(RewritePatternSet &patterns) const final {
     populateTestReductionPatterns(patterns);
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // TestDialect
 //===----------------------------------------------------------------------===//
 
 static void testSideEffectOpGetEffect(
     Operation *op,
     SmallVectorImpl<SideEffects::EffectInstance<TestEffects::Effect>> &effects);
struct FoldToCallOpPattern : public OpRewritePattern<FoldToCallOp> {
 
   LogicalResult matchAndRewrite(FoldToCallOp op,
                                 PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), op.getCalleeAttr(),
                                         ValueRange());
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void FoldToCallOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<FoldToCallOpPattern>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // Test Format* operations
struct TestRemoveOpWithInnerOps
   void initialize() { setDebugName("TestRemoveOpWithInnerOps"); }
 
   LogicalResult matchAndRewrite(TestOpWithRegionPattern op,
                                 PatternRewriter &rewriter) const override {
     rewriter.eraseOp(op);
     return success();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 void TestOpWithRegionPattern::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<TestRemoveOpWithInnerOps>(context);
 }
 
 OpFoldResult TestOpWithRegionFold::fold(ArrayRef<Attribute> operands) {
   return getOperand();

 // Test SideEffect interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A test resource for side effects.
 struct TestResource : public SideEffects::Resource::Base<TestResource> {
   StringRef getName() final { return "<Test>"; }
 };
-} // end anonymous namespace
+} // namespace
 
 static void testSideEffectOpGetEffect(
     Operation *op,
     SmallVectorImpl<SideEffects::EffectInstance<TestEffects::Effect>>
         &effects) {
   auto effectsAttr = op->getAttrOfType<AffineMapAttr>("effect_parameter");
   if (!effectsAttr)
     return;

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

 static int64_t opMIncreasingValue = 314159265;
 static Attribute OpMTest(PatternRewriter &rewriter, Value val) {
   int64_t i = opMIncreasingValue++;
   return rewriter.getIntegerAttr(rewriter.getIntegerType(32), i);
 }
 
 namespace {
 #include "TestPatterns.inc"
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Test Reduce Pattern Interface
 //===----------------------------------------------------------------------===//
 
 void test::populateTestReductionPatterns(RewritePatternSet &patterns) {
   populateWithGenerated(patterns);
 }
void runOnFunction() override {
     // Verify named pattern is generated with expected name.
     patterns.add<FoldingPattern, TestNamedPatternRule,
                  FolderInsertBeforePreviouslyFoldedConstantPattern>(
         &getContext());
 
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ReturnType Driver.
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Generate ops for each instance where the type can be successfully inferred.
 template <typename OpTy>
if (getFunction().getName() == "testReifyFunctions") {
         if (isa<OpWithShapedTypeInferTypeInterfaceOp>(op))
           ops.push_back(&op);
       // Generate test patterns for each, but skip terminator.
       for (auto *op : ops)
         reifyReturnShape(op);
     }
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace {
 struct TestDerivedAttributeDriver
     : public PassWrapper<TestDerivedAttributeDriver, FunctionPass> {
   StringRef getArgument() const final { return "test-derived-attr"; }
   StringRef getDescription() const final {
     return "Run test derived attributes";
   }
   void runOnFunction() override;
 };
-} // end anonymous namespace
+} // namespace
 
 void TestDerivedAttributeDriver::runOnFunction() {
   getFunction().walk([](DerivedAttributeOpInterface dOp) {
     auto dAttr = dOp.materializeDerivedAttributes();
     if (!dAttr)
       return;
     for (auto d : dAttr)
       dOp.emitRemark() << d.getName().getValue() << " = " << d.getValue();
void runOnOperation() override {
     // Emit remarks for each legalizable operation.
     for (auto *op : legalizedOps)
       op->emitRemark() << "op '" << op->getName() << "' is legalizable";
   }
 
   /// The mode of conversion to use.
   ConversionMode mode;
 };
-} // end anonymous namespace
+} // namespace
 
 static llvm::cl::opt<TestLegalizePatternDriver::ConversionMode>
     legalizerConversionMode(
         "test-legalize-mode",
         llvm::cl::desc("The legalization mode to use with the test driver"),
         llvm::cl::init(TestLegalizePatternDriver::ConversionMode::Partial),
         llvm::cl::values(
             clEnumValN(TestLegalizePatternDriver::ConversionMode::Analysis,
target.addDynamicallyLegalOp<OneVResOneVOperandOp1>(
         [](Operation *op) { return op->getNumOperands() > 1; });
 
     if (failed(mlir::applyFullConversion(getFunction(), target,
                                          std::move(patterns)))) {
       signalPassFailure();
     }
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Test patterns without a specific root operation kind
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This pattern matches and removes any operation in the test dialect.
 struct RemoveTestDialectOps : public RewritePattern {
void runOnFunction() override {
 
     mlir::ConversionTarget target(getContext());
     target.addIllegalDialect<TestDialect>();
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Test type conversions
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct TestTypeConversionProducer
     : public OpConversionPattern<TestTypeProducerOp> {
void runOnOperation() override {
     patterns.add<TestTypeConversionAnotherProducer>(&getContext());
     mlir::populateFuncOpTypeConversionPattern(patterns, converter);
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Test Block Merging
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A rewriter pattern that tests that blocks can be merged.
 struct TestMergeBlock : public OpConversionPattern<TestMergeBlocksOp> {

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

 struct TestTraitFolder : public PassWrapper<TestTraitFolder, FunctionPass> {
   StringRef getArgument() const final { return "test-trait-folder"; }
   StringRef getDescription() const final { return "Run trait folding"; }
   void runOnFunction() override {
     (void)applyPatternsAndFoldGreedily(getFunction(),
                                        RewritePatternSet(&getContext()));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerTestTraitsPass() { PassRegistration<TestTraitFolder>(); }
 } // namespace mlir

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

static FailureOr<test::CustomParam> parse(AsmParser &parser) {
     return test::CustomParam{value.getValue()};
   }
 };
 inline mlir::AsmPrinter &operator<<(mlir::AsmPrinter &printer,
                                     test::CustomParam param) {
   return printer << param.value;
 }
 
-} // end namespace mlir
+} // namespace mlir
 
 #include "TestTypeInterfaces.h.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.h.inc"
 
 namespace test {
 

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

void TosaTestQuantUtilAPI::runOnFunction() {
   RewritePatternSet patterns(ctx);
   auto func = getFunction();
 
   patterns.add<ConvertTosaNegateOp>(ctx);
   patterns.add<ConvertTosaConv2DOp>(ctx);
   (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
 }
 
-} // anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerTosaTestQuantUtilAPIPass() {
   PassRegistration<TosaTestQuantUtilAPI>();
 }
 } // namespace mlir

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

struct TestVectorReduceToContractPatternsPatterns
   }
   void runOnFunction() override {
     RewritePatternSet patterns(&getContext());
     populateVectorReductionToContractPatterns(patterns);
     (void)applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestVectorLowerings() {
   PassRegistration<TestVectorToVectorLowering>();
 
   PassRegistration<TestVectorContractionLowering>();
 

mlir/test/lib/IR/TestBuiltinAttributeInterfaces.cpp

if (!values) {
       return;
     }
 
     llvm::interleaveComma(*values, diag, [&](T value) {
       diag << llvm::formatv("{0}", value).str();
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestBuiltinAttributeInterfaces() {
   PassRegistration<TestElementsAttrInterface>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestDiagnostics.cpp

void runOnOperation() override {
     });
   }
 
   ListOption<std::string> filters{
       *this, "filters", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("Specifies the diagnostic file name filters.")};
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestDiagnosticsPass() {
   PassRegistration<TestDiagnosticFilterPass>{};
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestDominance.cpp

dominanceTest.printDominance(getAnalysis<DominanceInfo>(),
                                  /*printCommonDominatorInfo=*/false);
 
     llvm::errs() << "--- Block PostDominance relationship ---\n";
     dominanceTest.printDominance(getAnalysis<PostDominanceInfo>(),
                                  /*printCommonDominatorInfo=*/false);
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestDominancePass() { PassRegistration<TestDominancePass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestFunc.cpp

void runOnOperation() override {
     for (FuncOp func : module.getOps<FuncOp>()) {
       auto sym = func->getAttrOfType<FlatSymbolRefAttr>("test.set_type_from");
       if (!sym)
         continue;
       func.setType(symbolTable.lookup<FuncOp>(sym.getValue()).getType());
     }
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerTestFunc() {
   PassRegistration<TestFuncInsertArg>();
 
   PassRegistration<TestFuncInsertResult>();
 
   PassRegistration<TestFuncEraseArg>();
 
   PassRegistration<TestFuncEraseResult>();
 
   PassRegistration<TestFuncSetType>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestInterfaces.cpp

getOperation().walk([](Operation *op) {
           (void)result;
         }
         if (auto testType = type.dyn_cast<TestType>())
           testType.printTypeE(op->getLoc());
       }
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestInterfaces() { PassRegistration<TestTypeInterfaces>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestMatchers.cpp

 /// This is a test pass for verifying matchers.
 struct TestMatchers : public PassWrapper<TestMatchers, FunctionPass> {
   void runOnFunction() override;
   StringRef getArgument() const final { return "test-matchers"; }
   StringRef getDescription() const final {
     return "Test C++ pattern matchers.";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 // This could be done better but is not worth the variadic template trouble.
 template <typename Matcher>
 static unsigned countMatches(FuncOp f, Matcher &matcher) {
   unsigned count = 0;
   f.walk([&count, &matcher](Operation *op) {
     if (matcher.match(op))
       ++count;

mlir/test/lib/IR/TestOpaqueLoc.cpp

ScopedDiagnosticHandler diagHandler(&getContext(), [](Diagnostic &diag) {
       os << ": " << diag << '\n';
       os.flush();
     });
 
     getOperation().walk([&](Operation *op) { op->emitOpError(); });
   }
 };
 
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestOpaqueLoc() { PassRegistration<TestOpaqueLoc>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/IR/TestOperationEquals.cpp

if (!first->hasAttr("strict_loc_check"))
       flags |= OperationEquivalence::IgnoreLocations;
     if (OperationEquivalence::isEquivalentTo(first, &module.getBody()->back(),
                                              mapValue, mapValue, flags))
       llvm::outs() << " compares equals.\n";
     else
       llvm::outs() << " compares NOT equals!\n";
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerTestOperationEqualPass() {
   PassRegistration<TestOperationEqualPass>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestPrintDefUse.cpp

getOperation()->walk([](Operation *op) {
         }
         for (Operation *userOp : result.getUsers()) {
           llvm::outs() << "    - " << userOp->getName() << "\n";
         }
       }
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerTestPrintDefUsePass() { PassRegistration<TestPrintDefUsePass>(); }
 } // namespace mlir

mlir/test/lib/IR/TestPrintNesting.cpp

struct TestPrintNestingPass
   IdentRAII pushIndent() { return IdentRAII(++indent); }
 
   llvm::raw_ostream &printIndent() {
     for (int i = 0; i < indent; ++i)
       llvm::outs() << "  ";
     return llvm::outs();
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerTestPrintNestingPass() {
   PassRegistration<TestPrintNestingPass>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestSideEffects.cpp

module.walk([&](TestEffectOpInterface op) {
 
       for (const TestEffects::EffectInstance &instance : testEffects) {
         op.emitRemark() << "found a parametric effect with "
                         << instance.getParameters();
       }
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerSideEffectTestPasses() { PassRegistration<SideEffectsPass>(); }
 } // namespace mlir

mlir/test/lib/IR/TestSymbolUses.cpp

module.getBodyRegion().walk([&](Operation *nestedOp) {
       StringAttr newName = nestedOp->getAttrOfType<StringAttr>("sym.new_name");
       if (!newName)
         return;
       symbolUsers.replaceAllUsesWith(nestedOp, newName);
       SymbolTable::setSymbolName(nestedOp, newName);
     });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 void registerSymbolTestPasses() {
   PassRegistration<SymbolUsesPass>();
 
   PassRegistration<SymbolReplacementPass>();
 }
 } // namespace mlir

mlir/test/lib/IR/TestVisitors.cpp

struct TestIRVisitorsPass
   StringRef getDescription() const final { return "Test various visitors."; }
   void runOnOperation() override {
     Operation *op = getOperation();
     testPureCallbacks(op);
     testSkipErasureCallbacks(op);
     testNoSkipErasureCallbacks(op);
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestIRVisitorsPass() { PassRegistration<TestIRVisitorsPass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Pass/TestPassManager.cpp

struct TestStatisticPass
   StringRef getDescription() const final { return "Test pass statistics"; }
 
   Statistic opCount{this, "num-ops", "Number of operations counted"};
 
   void runOnOperation() final {
     getOperation()->walk([&](Operation *) { ++opCount; });
   }
 };
-} // end anonymous namespace
+} // namespace
 
 static void testNestedPipeline(OpPassManager &pm) {
   // Nest a module pipeline that contains:
   /// A module pass.
   auto &modulePM = pm.nest<ModuleOp>();
   modulePM.addPass(std::make_unique<TestModulePass>());
   /// A nested function pass.
   auto &nestedFunctionPM = modulePM.nest<FuncOp>();

mlir/test/lib/Reducer/MLIRTestReducer.cpp

 struct TestReducer : public PassWrapper<TestReducer, OperationPass<>> {
   StringRef getArgument() const final { return "test-mlir-reducer"; }
   StringRef getDescription() const final {
     return "Tests MLIR Reduce tool by generating failures";
   }
   void runOnOperation() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 void TestReducer::runOnOperation() {
   getOperation()->walk([&](Operation *op) {
     StringRef opName = op->getName().getStringRef();
 
     if (opName.contains("op_crash")) {
       llvm::errs() << "MLIR Reducer Test generated failure: Found "
                       "\"crashOp\" operation\n";
       exit(1);
     }
   });
 }
 
 namespace mlir {
 void registerTestReducer() { PassRegistration<TestReducer>(); }
 } // namespace mlir

mlir/test/lib/Rewrite/TestPDLByteCode.cpp

void runOnOperation() final {
 
     RewritePatternSet patternList(std::move(pdlPattern));
 
     // Invoke the pattern driver with the provided patterns.
     (void)applyPatternsAndFoldGreedily(irModule.getBodyRegion(),
                                        std::move(patternList));
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerTestPDLByteCodePass() { PassRegistration<TestPDLByteCodePass>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestConstantFold.cpp

StringRef getDescription() const final {
     return "Test operation constant folding";
   }
   // All constants in the function post folding.
   SmallVector<Operation *, 8> existingConstants;
 
   void foldOperation(Operation *op, OperationFolder &helper);
   void runOnFunction() override;
 };
-} // end anonymous namespace
+} // namespace
 
 void TestConstantFold::foldOperation(Operation *op, OperationFolder &helper) {
   auto processGeneratedConstants = [this](Operation *op) {
     existingConstants.push_back(op);
   };
 
   // Attempt to fold the specified operation, including handling unused or
   // duplicated constants.

mlir/test/lib/Transforms/TestInlining.cpp

for (auto caller : callers) {
       // If the inlining was successful then erase the call and callee if
       // possible.
       caller.erase();
       if (callee.use_empty())
         callee.erase();
     }
   }
 };
-} // end anonymous namespace
+} // namespace
 
 namespace mlir {
 namespace test {
 void registerInliner() { PassRegistration<Inliner>(); }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopFusion.cpp

 struct TestLoopFusion : public PassWrapper<TestLoopFusion, FunctionPass> {
   StringRef getArgument() const final { return "test-loop-fusion"; }
   StringRef getDescription() const final {
     return "Tests loop fusion utility functions.";
   }
   void runOnFunction() override;
 };
 
-} // end anonymous namespace
+} // namespace
 
 // 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/test/mlir-tblgen/attrdefs.td

 // RUN: mlir-tblgen -gen-attrdef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_ATTRDEF_CLASSES
 // DECL: #undef GET_ATTRDEF_CLASSES
 
 // DECL: namespace mlir {
 // DECL: class AsmParser;
 // DECL: class AsmPrinter;
-// DECL: } // end namespace mlir
+// DECL: } // namespace mlir
 
 // DEF: #ifdef GET_ATTRDEF_LIST
 // DEF: #undef GET_ATTRDEF_LIST
 // DEF: ::test::SimpleAAttr,
 // DEF: ::test::CompoundAAttr,
 // DEF: ::test::IndexAttr,
 // DEF: ::test::SingleParameterAttr
 

mlir/test/mlir-tblgen/default-type-attr-print-parser.td

 // ATTR: }
 
 // ATTR: void TestDialect::printAttribute(::mlir::Attribute attr,
 // ATTR:                          ::mlir::DialectAsmPrinter &printer) const {
 // ATTR:   if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
 // ATTR:     return;
 // ATTR: }
 
-// ATTR: } // end namespace test
+// ATTR: } // namespace test
 
 def TypeA : TestType<"TypeA"> {
   let mnemonic = "type_a";
 }
 
 // TYPE: namespace test {
 
 // TYPE: ::mlir::Type TestDialect::parseType(::mlir::DialectAsmParser &parser) const {

 // TYPE: }
 
 // TYPE: void TestDialect::printType(::mlir::Type type,
 // TYPE:                     ::mlir::DialectAsmPrinter &printer) const {
 // TYPE:   if (::mlir::succeeded(generatedTypePrinter(type, printer)))
 // TYPE:     return;
 // TYPE: }
 
-// TYPE: } // end namespace test
+// TYPE: } // namespace test

mlir/test/mlir-tblgen/typedefs.td

 // RUN: mlir-tblgen -gen-typedef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_TYPEDEF_CLASSES
 // DECL: #undef GET_TYPEDEF_CLASSES
 
 // DECL: namespace mlir {
 // DECL: class AsmParser;
 // DECL: class AsmPrinter;
-// DECL: } // end namespace mlir
+// DECL: } // namespace mlir
 
 // DEF: #ifdef GET_TYPEDEF_LIST
 // DEF: #undef GET_TYPEDEF_LIST
 // DEF: ::test::SimpleAType,
 // DEF: ::test::CompoundAType,
 // DEF: ::test::IndexType,
 // DEF: ::test::SingleParameterType,
 // DEF: ::test::IntegerType

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

private:
   /// exist if and only if the def has more than zero parameters.
   Optional<Class> storageCls;
 
   /// The C++ base value of the def, either "Attribute" or "Type".
   StringRef valueType;
   /// The prefix/suffix of the TableGen def name, either "Attr" or "Type".
   StringRef defType;
 };
-} // end anonymous namespace
+} // namespace
 
 DefGen::DefGen(const AttrOrTypeDef &def)
     : def(def), params(def.getParameters()), defCls(def.getCppClassName()),
       valueType(isa<AttrDef>(def) ? "Attribute" : "Type"),
       defType(isa<AttrDef>(def) ? "Attr" : "Type") {
   // If a storage class is needed, create one.
   if (def.getNumParameters() > 0)
     storageCls.emplace(def.getStorageClassName(), /*isStruct=*/true);
AttrDefGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
                      "Attribute", /*isAttrGenerator=*/true) {}
 };
 /// A specialized generator for TypeDefs.
 struct TypeDefGenerator : public DefGenerator {
   TypeDefGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
       : DefGenerator(records.getAllDerivedDefinitions("TypeDef"), os, "Type",
                      "Type", /*isAttrGenerator=*/false) {}
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // GEN: Declarations
 //===----------------------------------------------------------------------===//
 
 /// Print this above all the other declarations. Contains type declarations used
 /// later on.
 static const char *const typeDefDeclHeader = R"(
 namespace mlir {
 class AsmParser;
 class AsmPrinter;
-} // end namespace mlir
+} // namespace mlir
 )";
 
 bool DefGenerator::emitDecls(StringRef selectedDialect) {
   emitSourceFileHeader((defType + "Def Declarations").str(), os);
   IfDefScope scope("GET_" + defType.upper() + "DEF_CLASSES", os);
 
   // Output the common "header".
   os << typeDefDeclHeader;

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.h

 void generateAttrOrTypeFormat(const AttrOrTypeDef &def, MethodBody &parser,
                               MethodBody &printer);
 
 /// From the parameter name, get the name of the accessor function in camelcase.
 /// The first letter of the parameter is upper-cased and prefixed with "get".
 /// E.g. 'value' -> 'getValue'.
 std::string getParameterAccessorName(llvm::StringRef name);
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRTBLGEN_ATTRORTYPEFORMATGEN_H_

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

 ///   `{` param-name `=` param-value (`,` param-name `=` param-value)* `}`
 ///
 class StructDirective
     : public ParamsDirectiveBase<Element::Kind::StructDirective> {
 public:
   using Base::Base;
 };
 
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Format Strings
 //===----------------------------------------------------------------------===//
 
 /// Default parser for attribute or type parameters.
 static const char *const defaultParameterParser =
     "::mlir::FieldParser<$0>::parse($_parser)";
private:
   /// The list of top-level format elements returned by the assembly format
   /// parser.
   std::vector<std::unique_ptr<Element>> elements;
 
   /// Flags for printing spaces.
   bool shouldEmitSpace;
   bool lastWasPunctuation;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // ParserGen
 //===----------------------------------------------------------------------===//
 
 void AttrOrTypeFormat::genParser(MethodBody &os) {
   FmtContext ctx;
   ctx.addSubst("_parser", "parser");
private:
   /// The current token in the stream.
   FormatToken curToken;
   /// Attribute or type tablegen def.
   const AttrOrTypeDef &def;
 
   /// Seen attribute or type parameters.
   llvm::BitVector seenParams;
 };
-} // end anonymous namespace
+} // namespace
 
 FailureOr<AttrOrTypeFormat> FormatParser::parse() {
   std::vector<std::unique_ptr<Element>> elements;
   elements.reserve(16);
 
   /// Parse the format elements.
   while (curToken.getKind() != FormatToken::eof) {
     auto element = parseElement(TopLevelContext);

mlir/tools/mlir-tblgen/DialectGen.cpp

llvm::cl::opt<std::string>
     selectedDialect("dialect", llvm::cl::desc("The dialect to gen for"),
                     llvm::cl::cat(dialectGenCat), llvm::cl::CommaSeparated);
 
 /// Utility iterator used for filtering records for a specific dialect.
 namespace {
 using DialectFilterIterator =
     llvm::filter_iterator<ArrayRef<llvm::Record *>::iterator,
                           std::function<bool(const llvm::Record *)>>;
-} // end anonymous namespace
+} // namespace
 
 /// Given a set of records for a T, filter the ones that correspond to
 /// the given dialect.
 template <typename T>
 static iterator_range<DialectFilterIterator>
 filterForDialect(ArrayRef<llvm::Record *> records, Dialect &dialect) {
   auto filterFn = [&](const llvm::Record *record) {
     return T(record).getDialect() == dialect;

mlir/tools/mlir-tblgen/FormatGen.h

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/SMLoc.h"
 
 namespace llvm {
 class SourceMgr;
-} // end namespace llvm
+} // namespace llvm
 
 namespace mlir {
 namespace tblgen {
 
 //===----------------------------------------------------------------------===//
 // FormatToken
 //===----------------------------------------------------------------------===//
 

 /// Returns true if the given string is valid format literal element.
 /// If `emitError` is provided, it is invoked with the reason for the failure.
 bool isValidLiteral(StringRef value,
                     function_ref<void(Twine)> emitError = nullptr);
 
 /// Whether a failure in parsing the assembly format should be a fatal error.
 extern llvm::cl::opt<bool> formatErrorIsFatal;
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRTBLGEN_FORMATGEN_H_

mlir/tools/mlir-tblgen/OpClass.h

 
 private:
   /// Hand-written extra class declarations.
   StringRef extraClassDeclaration;
   /// The parent class, which also contains the traits to be inherited.
   ParentClass &parent;
 };
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRTBLGEN_OPCLASS_H_

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

public:
   const Operator &getOp() const { return op; }
 
 private:
   // The operation ODS wrapper.
   const Operator &op;
   // True if code is being generate for an op. False for an adaptor.
   const bool emitForOp;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Op emitter
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Helper class to emit a record into the given output stream.
 class OpEmitter {
private:
 
   // The format context for verification code generation.
   FmtContext verifyCtx;
 
   // The emitter containing all of the locally emitted verification functions.
   const StaticVerifierFunctionEmitter &staticVerifierEmitter;
 };
 
-} // end anonymous namespace
+} // namespace
 
 // Populate the format context `ctx` with substitutions of attributes, operands
 // and results.
 static void populateSubstitutions(const OpOrAdaptorHelper &emitHelper,
                                   FmtContext &ctx) {
   // Populate substitutions for attributes.
   auto &op = emitHelper.getOp();
   for (const auto &namedAttr : op.getAttributes())
private:
   // Add verification function. This generates a verify method for the adaptor
   // which verifies all the op-independent attribute constraints.
   void addVerification();
 
   const Operator &op;
   Class adaptor;
   StaticVerifierFunctionEmitter &staticVerifierEmitter;
 };
-} // end anonymous namespace
+} // namespace
 
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(
     const Operator &op, StaticVerifierFunctionEmitter &staticVerifierEmitter)
     : op(op), adaptor(op.getAdaptorName()),
       staticVerifierEmitter(staticVerifierEmitter) {
   adaptor.addField("::mlir::ValueRange", "odsOperands");
   adaptor.addField("::mlir::DictionaryAttr", "odsAttrs");
   adaptor.addField("::mlir::RegionRange", "odsRegions");

mlir/tools/mlir-tblgen/OpFormatGen.h

 namespace mlir {
 namespace tblgen {
 class OpClass;
 class Operator;
 
 // Generate the assembly format for the given operator.
 void generateOpFormat(const Operator &constOp, OpClass &opClass);
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif // MLIR_TOOLS_MLIRTBLGEN_OPFORMATGEN_H_

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 
 /// This class represents a variable that refers to a result.
 using ResultVariable =
     VariableElement<NamedTypeConstraint, Element::Kind::ResultVariable>;
 
 /// This class represents a variable that refers to a successor.
 using SuccessorVariable =
     VariableElement<NamedSuccessor, Element::Kind::SuccessorVariable>;
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // DirectiveElement
 
 namespace {
 /// This class implements single kind directives.
 template <Element::Kind type> class DirectiveElement : public Element {
 public:
public:
 
   /// Return the literal for this element.
   StringRef getLiteral() const { return literal; }
 
 private:
   /// The spelling of the literal for this element.
   StringRef literal;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // WhitespaceElement
 
 namespace {
 /// This class represents a whitespace element, e.g. newline or space. It's a
 /// literal that is printed but never parsed.
 class WhitespaceElement : public Element {
public:
 
   /// Returns true if this element should print as a space. Otherwise, the
   /// element should omit printing a space between the surrounding elements.
   bool getValue() const { return value; }
 
 private:
   bool value;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // OptionalElement
 
 namespace {
 /// This class represents a group of elements that are optionally emitted based
 /// upon an optional variable of the operation, and a group of elements that are
 /// emotted when the anchor element is not present.
private:
   /// The child elements of `else` branch of this optional.
   std::vector<std::unique_ptr<Element>> elseElements;
   /// The index of the element that acts as the anchor for the optional group.
   unsigned anchor;
   /// The index of the first element that is parsed (is not a
   /// WhitespaceElement).
   unsigned parseStart;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // OperationFormat
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 using ConstArgument =
struct OperationFormat {
 
   /// The index of the buildable type, if valid, for every operand and result.
   std::vector<TypeResolution> operandTypes, resultTypes;
 
   /// The set of attributes explicitly used within the format.
   SmallVector<const NamedAttribute *, 8> usedAttributes;
   llvm::StringSet<> inferredAttributes;
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Parser Gen
 
 /// Returns true if we can format the given attribute as an EnumAttr in the
 /// parser format.
 static bool canFormatEnumAttr(const NamedAttribute *attr) {
   Attribute baseAttr = attr->attr.getBaseAttr();
enum class ArgumentLengthKind {
   VariadicOfVariadic,
   /// The argument is variadic, and may contain 0->N elements.
   Variadic,
   /// The argument is optional, and may contain 0 or 1 elements.
   Optional,
   /// The argument is a single element, i.e. always represents 1 element.
   Single
 };
-} // end anonymous namespace
+} // namespace
 
 /// Get the length kind for the given constraint.
 static ArgumentLengthKind
 getArgumentLengthKind(const NamedTypeConstraint *var) {
   if (var->isOptional())
     return ArgumentLengthKind::Optional;
   if (var->isVariadicOfVariadic())
     return ArgumentLengthKind::VariadicOfVariadic;
private:
   bool hasAllRegions = false, hasAllSuccessors = false;
   bool canInferResultTypes = false;
   llvm::SmallBitVector seenOperandTypes, seenResultTypes;
   llvm::SmallSetVector<const NamedAttribute *, 8> seenAttrs;
   llvm::DenseSet<const NamedTypeConstraint *> seenOperands;
   llvm::DenseSet<const NamedRegion *> seenRegions;
   llvm::DenseSet<const NamedSuccessor *> seenSuccessors;
 };
-} // end anonymous namespace
+} // namespace
 
 LogicalResult FormatParser::parse() {
   llvm::SMLoc loc = curToken.getLoc();
 
   // Parse each of the format elements into the main format.
   while (curToken.getKind() != FormatToken::eof) {
     std::unique_ptr<Element> element;
     if (failed(parseElement(element, TopLevelContext)))

mlir/tools/mlir-tblgen/OpGenHelpers.h

 namespace mlir {
 namespace tblgen {
 
 /// Returns all the op definitions filtered by the user. The filtering is via
 /// command-line option "op-include-regex" and "op-exclude-regex".
 std::vector<llvm::Record *>
 getRequestedOpDefinitions(const llvm::RecordKeeper &recordKeeper);
 
-} // end namespace tblgen
-} // end namespace mlir
+} // namespace tblgen
+} // namespace mlir
 
 #endif //  MLIR_TOOLS_MLIRTBLGEN_OPGENHELPERS_H_

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

TypeInterfaceGenerator(const llvm::RecordKeeper &records, raw_ostream &os)
     interfaceBaseType = "TypeInterface";
     valueTemplate = "ConcreteType";
     StringRef castCode = "(tablegen_opaque_val.cast<ConcreteType>())";
     nonStaticMethodFmt.addSubst("_type", castCode).withSelf(castCode);
     traitMethodFmt.addSubst("_type",
                             "(*static_cast<const ConcreteType *>(this))");
   }
 };
-} // end anonymous namespace
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // GEN: Interface definitions
 //===----------------------------------------------------------------------===//
 
 static void emitInterfaceDef(Interface interface, StringRef valueType,
                              raw_ostream &os) {
   StringRef interfaceName = interface.getName();
void InterfaceGenerator::emitInterfaceDecl(Interface interface) {
   emitConceptDecl(interface);
   emitModelDecl(interface);
   os << "};";
 
   // Emit the derived trait for the interface.
   os << "template <typename " << valueTemplate << ">\n";
   os << "struct " << interface.getName() << "Trait;\n";
 
-  os << "\n} // end namespace detail\n";
+  os << "\n} // namespace detail\n";
 
   // Emit the main interface class declaration.
   os << llvm::formatv("class {0} : public ::mlir::{3}<{1}, detail::{2}> {\n"
                       "public:\n"
                       "  using ::mlir::{3}<{1}, detail::{2}>::{3};\n",
                       interfaceName, interfaceName, interfaceTraitsName,
                       interfaceBaseType);
 
InterfaceGenRegistration(StringRef genArg, StringRef genDesc)
                 [](const llvm::RecordKeeper &records, raw_ostream &os) {
                   return GeneratorT(records, os).emitInterfaceDocs();
                 }) {}
 
   std::string genDeclArg, genDefArg, genDocArg;
   std::string genDeclDesc, genDefDesc, genDocDesc;
   mlir::GenRegistration genDecls, genDefs, genDocs;
 };
-} // end anonymous namespace
+} // namespace
 
 static InterfaceGenRegistration<AttrInterfaceGenerator> attrGen("attr",
                                                                 "attribute");
 static InterfaceGenRegistration<OpInterfaceGenerator> opGen("op", "op");
 static InterfaceGenRegistration<TypeInterfaceGenerator> typeGen("type", "type");

mlir/tools/mlir-tblgen/RewriterGen.cpp

 namespace llvm {
 template <>
 struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
   static void format(const mlir::tblgen::Pattern::IdentifierLine &v,
                      raw_ostream &os, StringRef style) {
     os << v.first << ":" << v.second;
   }
 };
-} // end namespace llvm
+} // namespace llvm
 
 //===----------------------------------------------------------------------===//
 // PatternEmitter
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 class StaticMatcherHelper;
private:
 
   // The DagLeaf which contains type or attr constraint.
   DenseSet<DagLeaf> constraints;
 
   // Static type/attribute verification function emitter.
   StaticVerifierFunctionEmitter staticVerifierEmitter;
 };
 
-} // end anonymous namespace
+} // namespace
 
 PatternEmitter::PatternEmitter(Record *pat, RecordOperatorMap *mapper,
                                raw_ostream &os, StaticMatcherHelper &helper)
     : loc(pat->getLoc()), opMap(mapper), pattern(pat, mapper),
       symbolInfoMap(pat->getLoc()), staticMatcherHelper(helper), nextValueId(0),
       os(os) {
   fmtCtx.withBuilder("rewriter");
 }

mlir/unittests/Conversion/PDLToPDLInterp/RootOrderingTest.cpp

TEST_F(RootOrderingTest, contraction) {
   graph[v[1]][v[0]].cost = {10, 0};
   graph[v[2]][v[0]].cost = {5, 0};
   graph[v[2]][v[1]].cost = {1, 0};
   graph[v[3]][v[2]].cost = {2, 0};
   graph[v[1]][v[3]].cost = {3, 0};
   check(10, {{v[0], {}}, {v[2], v[0]}, {v[3], v[2]}, {v[1], v[3]}});
 }
 
-} // end namespace
+} // namespace

mlir/unittests/Dialect/Quant/QuantizationUtilsTest.cpp

TEST(QuantizationUtilsTest, convertRankedSparseAttrUniform) {
   EXPECT_TRUE(returnedValue.isa<SparseElementsAttr>());
 
   // Check Elements attribute element value is expected.
   auto firstValue =
       returnedValue.cast<ElementsAttr>().getValues<Attribute>()[{0, 0}];
   EXPECT_EQ(firstValue.cast<IntegerAttr>().getInt(), 5);
 }
 
-} // end namespace
+} // namespace

mlir/unittests/Dialect/SparseTensor/MergerTest.cpp

MergerTest3T1L() : MergerTestBase(3, 1) {
     merger.setDim(t1, l0, Dim::kSparse);
 
     // Tensor 2: dense output vector.
     merger.addExp(Kind::kTensor, t2, -1u);
     merger.setDim(t2, l0, Dim::kDense);
   }
 };
 
-} // anonymous namespace
+} // namespace
 
 /// Vector addition of 2 vectors, i.e.:
 ///   a(i) = b(i) + c(i)
 /// which should form the 3 lattice points
 /// {
 ///   lat( i_00 i_01 / (tensor_0 + tensor_1) )
 ///   lat( i_00 / tensor_0 )
 ///   lat( i_01 / tensor_1 )

mlir/unittests/IR/AttributeTest.cpp

TEST(SparseElementsAttrTest, GetZero) {
   EXPECT_EQ(zeroFloatValue.cast<FloatAttr>().getValueAsDouble(), 0.0f);
   EXPECT_TRUE(zeroFloatValue.getType() == floatTy);
 
   auto zeroStringValue = sparseString.getValues<Attribute>()[{1, 1}];
   EXPECT_TRUE(zeroStringValue.cast<StringAttr>().getValue().empty());
   EXPECT_TRUE(zeroStringValue.getType() == stringTy);
 }
 
-} // end namespace
+} // namespace

mlir/unittests/IR/DialectTest.cpp

TEST(Dialect, RepeatedInterfaceRegistrationDeath) {
 
   // This triggers an assertion in debug mode.
 #ifndef NDEBUG
   ASSERT_DEATH(context.loadDialect<RepeatedRegistrationDialect>(),
                "interface kind has already been registered");
 #endif
 }
 
-} // end namespace
+} // namespace

mlir/unittests/IR/InterfaceAttachmentTest.cpp

TEST(InterfaceAttachment, OperationDelayedContextAppend) {
   context.appendDialectRegistry(registry);
 
   EXPECT_TRUE(isa<TestExternalOpInterface>(module->getOperation()));
   EXPECT_TRUE(isa<TestExternalOpInterface>(opJ.getOperation()));
   EXPECT_TRUE(isa<TestExternalOpInterface>(opH.getOperation()));
   EXPECT_FALSE(isa<TestExternalOpInterface>(opI.getOperation()));
 }
 
-} // end namespace
+} // namespace

mlir/unittests/IR/OperationSupportTest.cpp

ASSERT_FALSE(dup.hasValue());
     ++it;
     EXPECT_EQ(it->getName(), b.getStringAttr("zoo"));
     EXPECT_EQ(it->getValue(), b.getStringAttr("z"));
   }
 
   attrs.assign({});
   ASSERT_TRUE(attrs.empty());
 }
-} // end namespace
+} // namespace

mlir/unittests/IR/ShapedTypeTest.cpp

TEST(ShapedTypeTest, CloneVector) {
   ASSERT_NE(vectorOriginalType, vectorNewType);
   ASSERT_EQ(vectorType.clone(vectorNewType),
             VectorType::get(vectorOriginalShape, vectorNewType));
   // Update both.
   ASSERT_EQ(vectorType.clone(vectorNewShape, vectorNewType),
             VectorType::get(vectorNewShape, vectorNewType));
 }
 
-} // end namespace
+} // namespace

mlir/unittests/IR/SubElementInterfaceTest.cpp

DictionaryAttr dictAttr =
       builder.getDictionaryAttr(builder.getNamedAttr("array", boolArrayAttr));
 
   SmallVector<Attribute> subAttrs;
   dictAttr.walkSubAttrs([&](Attribute attr) { subAttrs.push_back(attr); });
   EXPECT_EQ(llvm::makeArrayRef(subAttrs),
             ArrayRef<Attribute>({trueAttr, falseAttr, boolArrayAttr}));
 }
 
-} // end namespace
+} // namespace

mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp

struct DLTestDialect : Dialect {
   Type parseType(DialectAsmParser &parser) const override {
     bool ok = succeeded(parser.parseKeyword("single_query"));
     (void)ok;
     assert(ok);
     return SingleQueryType::get(parser.getContext());
   }
 };
 
-} // end namespace
+} // namespace
 
 TEST(DataLayout, FallbackDefault) {
   const char *ir = R"MLIR(
 module {}
   )MLIR";
 
   DialectRegistry registry;
   registry.insert<DLTIDialect, DLTestDialect>();

mlir/unittests/Pass/AnalysisManagerTest.cpp

TEST(AnalysisManagerTest, DependentAnalysis2Ctors) {
   ModuleAnalysisManager mam(*module, /*passInstrumentor=*/nullptr);
   AnalysisManager am = mam;
 
   auto &an = am.getAnalysis<AnalysisWith2Ctors>();
   EXPECT_FALSE(an.ctor1called);
   EXPECT_TRUE(an.ctor2called);
 }
 
-} // end namespace
+} // namespace

mlir/unittests/Pass/PassManagerTest.cpp

struct InvalidPass : Pass {
   void runOnOperation() override {}
 
   /// A clone method to create a copy of this pass.
   std::unique_ptr<Pass> clonePass() const override {
     return std::make_unique<InvalidPass>(
         *static_cast<const InvalidPass *>(this));
   }
 };
-} // anonymous namespace
+} // namespace
 
 TEST(PassManagerTest, InvalidPass) {
   MLIRContext context;
   context.allowUnregisteredDialects();
 
   // Create a module
   OwningModuleRef module(ModuleOp::create(UnknownLoc::get(&context)));
 
TEST(PassManagerTest, InvalidPass) {
   pm.clear();
   result = pm.run(module.get());
   EXPECT_TRUE(succeeded(result));
 
   // Check that adding the pass at the top-level triggers a fatal error.
   ASSERT_DEATH(pm.addPass(std::make_unique<InvalidPass>()), "");
 }
 
-} // end namespace
+} // namespace