[mlir] Fix some of the warnings in MLIR code.

[pifon2a]

Summary

• extra ';' in the following files: mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp mlir/lib/Dialect/Shape/IR/Shape.cpp

• base class ‘mlir::ConvertVectorToSCFBase<ConvertVectorToSCFPass>’ should be explicitly initialized in the copy constructor [-Wextra] in mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

• warning: ‘bool Expression::operator==(const Expression&) const’ defined but not used [-Wunused-function] in mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

[rriddle]

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

653–654

You shouldn't need this at all.

[pifon2a]

Address the comment.

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

 }
 
 } // namespace mlir
 
 namespace {
 
 struct ConvertVectorToSCFPass
     : public ConvertVectorToSCFBase<ConvertVectorToSCFPass> {
   ConvertVectorToSCFPass() = default;
-  ConvertVectorToSCFPass(const ConvertVectorToSCFPass &pass) {}
   ConvertVectorToSCFPass(const VectorTransferToSCFOptions &options) {
     this->fullUnroll = options.unroll;
   }
 
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     auto *context = getFunction().getContext();
     populateVectorToSCFConversionPatterns(
         patterns, context, VectorTransferToSCFOptions().setUnroll(fullUnroll));

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

tileSizeComputationFunction = [tileSizes](OpBuilder &b, Operation *op) {
     b.setInsertionPointToStart(
         &op->getParentOfType<FuncOp>().getBody().front());
     return llvm::to_vector<4>(map_range(tileSizes, [&](int64_t s) {
       Value v = b.create<ConstantIndexOp>(op->getLoc(), s);
       return v;
     }));
   };
   return *this;
-};
+}
 
 /// Linalg base tiling pattern.
 mlir::linalg::LinalgBaseTilingPattern::LinalgBaseTilingPattern(
     StringRef opName, MLIRContext *context, LinalgTilingOptions options,
     LinalgMarker marker, PatternBenefit benefit)
     : RewritePattern(opName, {}, benefit, context), marker(marker),
       options(options) {}
 

mlir/lib/Dialect/Shape/IR/Shape.cpp

LogicalResult matchAndRewrite(AssumingOp op,
 
     // Merge blocks together as there was no branching behavior from the
     // AssumingOp.
     rewriter.mergeBlocks(assumingBlock, blockBeforeAssuming);
     rewriter.mergeBlocks(blockAfterAssuming, blockBeforeAssuming);
     return success();
   }
 };
-}; // namespace
+} // namespace
 
 void AssumingOp::getCanonicalizationPatterns(OwningRewritePatternList &patterns,
                                              MLIRContext *context) {
   // If taking a passing witness, inline region
   patterns.insert<AssumingWithTrue>(context);
 }
 
 //===----------------------------------------------------------------------===//

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

 struct Expression {
   enum class Kind {
     Uninitialized = 0,
     TensorExpr = 1,
     TensorUse = 2,
   };
 
   explicit Expression(Kind k = Kind::Uninitialized) : kind(k) {}
-  virtual ~Expression() = 0;
+  virtual ~Expression() = default;
 
-  bool operator==(const Expression &e) const;
   operator bool() const { return kind != Kind::Uninitialized; }
 
   Kind kind;
 };
 
 /// Encodes a tensor use of the form:
 ///
 ///   affine-expr-list ::= affine-expr (`,` affine-expr)*
struct TensorExpr : public Expression {
   template <typename Lambda, bool PreOrder>
   void visit(Lambda callback) const;
 
   StringRef operationName;
   SmallVector<std::unique_ptr<Expression>, 4> expressions;
   SetVector<unsigned> reductionDimensions;
 };
 
-Expression::~Expression() {}
-
-bool Expression::operator==(const Expression &e) const {
-  if (this->kind != e.kind)
-    return false;
-  if (e.kind == Expression::Kind::TensorUse)
-    return static_cast<const TensorUse &>(*this) ==
-           static_cast<const TensorUse &>(e);
-  if (e.kind == Expression::Kind::TensorExpr)
-    return static_cast<const TensorExpr &>(*this) ==
-           static_cast<const TensorExpr &>(e);
-  llvm_unreachable("Unexpected case");
-}
-
 /// This is a specialized parser for a TCDef.
 /// This maintains the dims it finds in an eager fashion.
 class TCParser {
   enum class EagerDiscoveryMode { None = 0, Symbols, Dimensions };
 
 public:
   explicit TCParser(Parser &p);