Demo fix for bugprone-copy-constructor-init (WIP)

[Mogball]

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

517

Wouldn't the appropriate fix for these be = default?

[mehdi_amini]

Full repo run

[rriddle]

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

39–40

Can we just do = default? Or just elide it?

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

604–607 ↗

(On Diff #396466)

This should be specified in tablegen, which should remove the need for the explicit copy constructor.

[mehdi_amini]

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

39–40

Good point, there is another clang-tidy transform that is supposed to make it = default ; not sure why it does not kick in here.

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

604–607 ↗

(On Diff #396466)

Done in https://github.com/llvm/llvm-project/commit/104a827ea6de0cbe0f5faef4407552ede31d165c

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

 
 namespace {
 struct LinalgComprehensiveModuleBufferize
     : public LinalgComprehensiveModuleBufferizeBase<
           LinalgComprehensiveModuleBufferize> {
   LinalgComprehensiveModuleBufferize() = default;
 
   LinalgComprehensiveModuleBufferize(
-      const LinalgComprehensiveModuleBufferize &p) {}
+      const LinalgComprehensiveModuleBufferize &p)
+      : LinalgComprehensiveModuleBufferizeBase(p) {}
 
   void runOnOperation() override;
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry
         .insert<bufferization::BufferizationDialect, linalg::LinalgDialect,
                 memref::MemRefDialect, tensor::TensorDialect,
                 vector::VectorDialect, scf::SCFDialect,

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

 //===----------------------------------------------------------------------===//
 // Passes implementation.
 //===----------------------------------------------------------------------===//
 
 struct SparsificationPass : public SparsificationBase<SparsificationPass> {
 
   SparsificationPass() = default;
   SparsificationPass(const SparsificationPass &pass)
-      : SparsificationBase<SparsificationPass>() {}
+      : SparsificationBase<SparsificationPass>(pass) {}
 
   /// Returns parallelization strategy given on command line.
   SparseParallelizationStrategy parallelOption() {
     switch (parallelization) {
     default:
       return SparseParallelizationStrategy::kNone;
     case 1:
       return SparseParallelizationStrategy::kDenseOuterLoop;

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

 
 struct TestAffineDataCopy
     : public PassWrapper<TestAffineDataCopy, FunctionPass> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine data copy utility functions.";
   }
   TestAffineDataCopy() = default;
-  TestAffineDataCopy(const TestAffineDataCopy &pass){};
+  TestAffineDataCopy(const TestAffineDataCopy &pass) : PassWrapper(pass){};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   void runOnFunction() override;
 
 private:
   Option<bool> clMemRefFilter{

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

 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestAffineLoopUnswitching
     : public PassWrapper<TestAffineLoopUnswitching, FunctionPass> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop unswitching / if/else hoisting";
   }
   TestAffineLoopUnswitching() = default;
-  TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass) {}
+  TestAffineLoopUnswitching(const TestAffineLoopUnswitching &pass)
+      : PassWrapper(pass) {}
 
   void runOnFunction() override;
 
   /// The maximum number of iterations to run this for.
   constexpr static unsigned kMaxIterations = 5;
 };
 
 } // namespace

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

 /// This pass applies the permutation on the first maximal perfect nest.
 struct TestLoopPermutation
     : public PassWrapper<TestLoopPermutation, FunctionPass> {
   StringRef getArgument() const final { return PASS_NAME; }
   StringRef getDescription() const final {
     return "Tests affine loop permutation utility";
   }
   TestLoopPermutation() = default;
-  TestLoopPermutation(const TestLoopPermutation &pass){};
+  TestLoopPermutation(const TestLoopPermutation &pass) : PassWrapper(pass){};
 
   void runOnFunction() override;
 
 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"),

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

struct TestComprehensiveFunctionBufferize
   }
 
   StringRef getDescription() const final {
     return "Test Comprehensive Bufferize of FuncOps (body only).";
   }
 
   TestComprehensiveFunctionBufferize() = default;
   TestComprehensiveFunctionBufferize(
-      const TestComprehensiveFunctionBufferize &pass) {}
+      const TestComprehensiveFunctionBufferize &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<bufferization::BufferizationDialect, linalg::LinalgDialect,
                     memref::MemRefDialect, tensor::TensorDialect,
                     vector::VectorDialect, scf::SCFDialect,
                     arith::ArithmeticDialect, AffineDialect>();
     affine_ext::registerBufferizableOpInterfaceExternalModels(registry);
     arith_ext::registerBufferizableOpInterfaceExternalModels(registry);

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

 namespace {
 struct TestLinalgCodegenStrategy
     : public PassWrapper<TestLinalgCodegenStrategy, FunctionPass> {
   StringRef getArgument() const final { return "test-linalg-codegen-strategy"; }
   StringRef getDescription() const final {
     return "Test Linalg Codegen Strategy.";
   }
   TestLinalgCodegenStrategy() = default;
-  TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass) {}
+  TestLinalgCodegenStrategy(const TestLinalgCodegenStrategy &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     gpu::GPUDialect,
                     linalg::LinalgDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,

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

 }
 
 namespace {
 struct TestLinalgDistribution
     : public PassWrapper<TestLinalgDistribution, FunctionPass> {
   StringRef getArgument() const final { return "test-linalg-distribution"; }
   StringRef getDescription() const final { return "Test Linalg distribution."; }
   TestLinalgDistribution() = default;
-  TestLinalgDistribution(const TestLinalgDistribution &pass) {}
+  TestLinalgDistribution(const TestLinalgDistribution &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, gpu::GPUDialect>();
   }
 
   void runOnFunction() override;
 };
 } // namespace
 

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

 struct TestLinalgTileAndFuseSequencePass
     : public PassWrapper<TestLinalgTileAndFuseSequencePass, FunctionPass> {
   StringRef getArgument() const final { return "test-linalg-tile-and-fuse"; }
   StringRef getDescription() const final {
     return "Test Linalg tiling and fusion of a sequence of Linalg operations.";
   }
   TestLinalgTileAndFuseSequencePass() = default;
   TestLinalgTileAndFuseSequencePass(
-      const TestLinalgTileAndFuseSequencePass &pass){};
+      const TestLinalgTileAndFuseSequencePass &pass)
+      : PassWrapper(pass){};
 
   ListOption<int64_t> tileSizes{
       *this, "tile-sizes", llvm::cl::desc("Tile sizes to use for ops"),
       llvm::cl::ZeroOrMore, llvm::cl::MiscFlags::CommaSeparated};
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();

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

 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgHoisting
     : public PassWrapper<TestLinalgHoisting, FunctionPass> {
   TestLinalgHoisting() = default;
-  TestLinalgHoisting(const TestLinalgHoisting &pass) {}
+  TestLinalgHoisting(const TestLinalgHoisting &pass) : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect>();
   }
   StringRef getArgument() const final { return "test-linalg-hoisting"; }
   StringRef getDescription() const final {
     return "Test Linalg hoisting functions.";
   }
 

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

 
 using namespace mlir;
 using namespace mlir::linalg;
 
 namespace {
 struct TestLinalgTransforms
     : public PassWrapper<TestLinalgTransforms, FunctionPass> {
   TestLinalgTransforms() = default;
-  TestLinalgTransforms(const TestLinalgTransforms &pass) {}
+  TestLinalgTransforms(const TestLinalgTransforms &pass) : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     // clang-format off
     registry.insert<AffineDialect,
                     memref::MemRefDialect,
                     scf::SCFDialect,
                     StandardOpsDialect,
                     vector::VectorDialect,

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

 
 using namespace mlir;
 
 namespace {
 struct TestMathPolynomialApproximationPass
     : public PassWrapper<TestMathPolynomialApproximationPass, FunctionPass> {
   TestMathPolynomialApproximationPass() = default;
   TestMathPolynomialApproximationPass(
-      const TestMathPolynomialApproximationPass &pass) {}
+      const TestMathPolynomialApproximationPass &pass)
+      : PassWrapper(pass) {}
 
   void runOnFunction() override;
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<arith::ArithmeticDialect, math::MathDialect,
                     vector::VectorDialect>();
     if (enableAvx2)
       registry.insert<x86vector::X86VectorDialect>();
   }

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

 using namespace mlir::linalg;
 using namespace mlir::vector;
 
 namespace {
 
 struct TestVectorToVectorLowering
     : public PassWrapper<TestVectorToVectorLowering, FunctionPass> {
   TestVectorToVectorLowering() = default;
-  TestVectorToVectorLowering(const TestVectorToVectorLowering &pass) {}
+  TestVectorToVectorLowering(const TestVectorToVectorLowering &pass)
+      : PassWrapper(pass) {}
   StringRef getArgument() const final {
     return "test-vector-to-vector-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns between ops in the vector dialect";
   }
 
   void getDependentDialects(DialectRegistry &registry) const override {
struct TestVectorContractionLowering
   StringRef getArgument() const final {
     return "test-vector-contraction-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorContractionLowering() = default;
-  TestVectorContractionLowering(const TestVectorContractionLowering &pass) {}
+  TestVectorContractionLowering(const TestVectorContractionLowering &pass)
+      : PassWrapper(pass) {}
 
   Option<bool> lowerToFlatMatrix{
       *this, "vector-lower-matrix-intrinsics",
       llvm::cl::desc("Lower vector.contract to llvm.intr.matrix.multiply"),
       llvm::cl::init(false)};
   Option<bool> lowerToOuterProduct{
       *this, "vector-outerproduct",
       llvm::cl::desc("Lower vector.contract to vector.outerproduct"),
struct TestVectorTransposeLowering
   StringRef getArgument() const final {
     return "test-vector-transpose-lowering";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns that lower contract ops in the vector "
            "dialect";
   }
   TestVectorTransposeLowering() = default;
-  TestVectorTransposeLowering(const TestVectorTransposeLowering &pass) {}
+  TestVectorTransposeLowering(const TestVectorTransposeLowering &pass)
+      : PassWrapper(pass) {}
 
   Option<bool> lowerToEltwise{
       *this, "eltwise",
       llvm::cl::desc("Lower 2-D vector.transpose to eltwise insert/extract"),
       llvm::cl::init(false)};
   Option<bool> lowerToFlatTranspose{
       *this, "flat",
       llvm::cl::desc("Lower 2-D vector.transpose to vector.flat_transpose"),
struct TestVectorUnrollingPatterns
   StringRef getArgument() const final {
     return "test-vector-unrolling-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to unroll contract ops in the vector "
            "dialect";
   }
   TestVectorUnrollingPatterns() = default;
-  TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass) {}
+  TestVectorUnrollingPatterns(const TestVectorUnrollingPatterns &pass)
+      : PassWrapper(pass) {}
   void runOnFunction() override {
     MLIRContext *ctx = &getContext();
     RewritePatternSet patterns(ctx);
     populateVectorUnrollPatterns(
         patterns, UnrollVectorOptions()
                       .setNativeShape(ArrayRef<int64_t>{2, 2})
                       .setFilterConstraint([](Operation *op) {
                         return success(isa<arith::AddFOp, vector::FMAOp>(op));
struct TestVectorDistributePatterns
   StringRef getArgument() const final {
     return "test-vector-distribute-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to distribute vector ops in the vector "
            "dialect";
   }
   TestVectorDistributePatterns() = default;
-  TestVectorDistributePatterns(const TestVectorDistributePatterns &pass) {}
+  TestVectorDistributePatterns(const TestVectorDistributePatterns &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   ListOption<int32_t> multiplicity{
       *this, "distribution-multiplicity", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("Set the multiplicity used for distributing vector")};
 

 
 struct TestVectorToLoopPatterns
     : public PassWrapper<TestVectorToLoopPatterns, FunctionPass> {
   StringRef getArgument() const final { return "test-vector-to-forloop"; }
   StringRef getDescription() const final {
     return "Test lowering patterns to break up a vector op into a for loop";
   }
   TestVectorToLoopPatterns() = default;
-  TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass) {}
+  TestVectorToLoopPatterns(const TestVectorToLoopPatterns &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<VectorDialect>();
     registry.insert<AffineDialect>();
   }
   Option<int32_t> multiplicity{
       *this, "distribution-multiplicity",
       llvm::cl::desc("Set the multiplicity used for distributing vector"),
       llvm::cl::init(32)};
StringRef getArgument() const final {
     return "test-vector-transfer-full-partial-split";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to split "
            "transfer ops via scf.if + linalg ops";
   }
   TestVectorTransferFullPartialSplitPatterns() = default;
   TestVectorTransferFullPartialSplitPatterns(
-      const TestVectorTransferFullPartialSplitPatterns &pass) {}
+      const TestVectorTransferFullPartialSplitPatterns &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, linalg::LinalgDialect, memref::MemRefDialect,
                     scf::SCFDialect>();
   }
 
   Option<bool> useLinalgOps{
       *this, "use-linalg-copy",
struct TestVectorTransferLoweringPatterns
   }
 };
 
 struct TestVectorMultiReductionLoweringPatterns
     : public PassWrapper<TestVectorMultiReductionLoweringPatterns,
                          FunctionPass> {
   TestVectorMultiReductionLoweringPatterns() = default;
   TestVectorMultiReductionLoweringPatterns(
-      const TestVectorMultiReductionLoweringPatterns &pass) {}
+      const TestVectorMultiReductionLoweringPatterns &pass)
+      : PassWrapper(pass) {}
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect>();
   }
   StringRef getArgument() const final {
     return "test-vector-multi-reduction-lowering-patterns";
   }
   StringRef getDescription() const final {
     return "Test lowering patterns to lower vector.multi_reduction to other "
struct TestVectorMultiReductionLoweringPatterns
   }
 };
 
 struct TestVectorTransferCollapseInnerMostContiguousDims
     : public PassWrapper<TestVectorTransferCollapseInnerMostContiguousDims,
                          FunctionPass> {
   TestVectorTransferCollapseInnerMostContiguousDims() = default;
   TestVectorTransferCollapseInnerMostContiguousDims(
-      const TestVectorTransferCollapseInnerMostContiguousDims &pass) {}
+      const TestVectorTransferCollapseInnerMostContiguousDims &pass)
+      : PassWrapper(pass) {}
 
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<memref::MemRefDialect, AffineDialect>();
   }
 
   StringRef getArgument() const final {
     return "test-vector-transfer-collapse-inner-most-dims";
   }