[MLIR] Make the `ConversionTarget` const ref in the DialectConversion (NFC)

[mehdi_amini]

Summary

It isn't mutated during the conversion already, communicate this through the API.

mlir/include/mlir/Transforms/DialectConversion.h

 /// operations. This method converts as many operations to the target as
 /// possible, ignoring operations that failed to legalize. This method only
 /// returns failure if there ops explicitly marked as illegal. If an
 /// `unconvertedOps` set is provided, all operations that are found not to be
 /// legalizable to the given `target` are placed within that set. (Note that if
 /// there is an op explicitly marked as illegal, the conversion terminates and
 /// the `unconvertedOps` set will not necessarily be complete.)
 LogicalResult
-applyPartialConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
+applyPartialConversion(ArrayRef<Operation *> ops, const ConversionTarget &target,
                        const FrozenRewritePatternSet &patterns,
                        DenseSet<Operation *> *unconvertedOps = nullptr);
 LogicalResult
-applyPartialConversion(Operation *op, ConversionTarget &target,
+applyPartialConversion(Operation *op, const ConversionTarget &target,
                        const FrozenRewritePatternSet &patterns,
                        DenseSet<Operation *> *unconvertedOps = nullptr);
 
 /// Apply a complete conversion on the given operations, and all nested
 /// operations. This method returns failure if the conversion of any operation
 /// fails, or if there are unreachable blocks in any of the regions nested
 /// within 'ops'.
 LogicalResult applyFullConversion(ArrayRef<Operation *> ops,
-                                  ConversionTarget &target,
+                                  const ConversionTarget &target,
                                   const FrozenRewritePatternSet &patterns);
-LogicalResult applyFullConversion(Operation *op, ConversionTarget &target,
+LogicalResult applyFullConversion(Operation *op, const ConversionTarget &target,
                                   const FrozenRewritePatternSet &patterns);
 
 /// Apply an analysis conversion on the given operations, and all nested
 /// operations. This method analyzes which operations would be successfully
 /// converted to the target if a conversion was applied. All operations that
 /// were found to be legalizable to the given 'target' are placed within the
 /// provided 'convertedOps' set; note that no actual rewrites are applied to the
 /// operations on success and only pre-existing operations are added to the set.

mlir/lib/Transforms/Utils/DialectConversion.cpp

 /// A set of rewrite patterns that can be used to legalize a given operation.
 using LegalizationPatterns = SmallVector<const Pattern *, 1>;
 
 /// This class defines a recursive operation legalizer.
 class OperationLegalizer {
 public:
   using LegalizationAction = ConversionTarget::LegalizationAction;
 
-  OperationLegalizer(ConversionTarget &targetInfo,
+  OperationLegalizer(const ConversionTarget &targetInfo,
                      const FrozenRewritePatternSet &patterns);
 
   /// Returns true if the given operation is known to be illegal on the target.
   bool isIllegal(Operation *op) const;
 
   /// Attempt to legalize the given operation. Returns success if the operation
   /// was legalized, failure otherwise.
   LogicalResult legalize(Operation *op, ConversionPatternRewriter &rewriter);
 
   /// Returns the conversion target in use by the legalizer.
-  ConversionTarget &getTarget() { return target; }
+  const ConversionTarget &getTarget() { return target; }
 
 private:
   /// Attempt to legalize the given operation by folding it.
   LogicalResult legalizeWithFold(Operation *op,
                                  ConversionPatternRewriter &rewriter);
 
   /// Attempt to legalize the given operation by applying a pattern. Returns
   /// success if the operation was legalized, failure otherwise.
unsigned applyCostModelToPatterns(
       LegalizationPatterns &patterns,
       DenseMap<OperationName, unsigned> &minOpPatternDepth,
       DenseMap<OperationName, LegalizationPatterns> &legalizerPatterns);
 
   /// The current set of patterns that have been applied.
   SmallPtrSet<const Pattern *, 8> appliedPatterns;
 
   /// The legalization information provided by the target.
-  ConversionTarget &target;
+  const ConversionTarget &target;
 
   /// The pattern applicator to use for conversions.
   PatternApplicator applicator;
 };
 } // namespace
 
-OperationLegalizer::OperationLegalizer(ConversionTarget &targetInfo,
+OperationLegalizer::OperationLegalizer(const ConversionTarget &targetInfo,
                                        const FrozenRewritePatternSet &patterns)
     : target(targetInfo), applicator(patterns) {
   // The set of patterns that can be applied to illegal operations to transform
   // them into legal ones.
   DenseMap<OperationName, LegalizationPatterns> legalizerPatterns;
   LegalizationPatterns anyOpLegalizerPatterns;
 
   buildLegalizationGraph(anyOpLegalizerPatterns, legalizerPatterns);
enum OpConversionMode {
   /// applied to the operations on success.
   Analysis,
 };
 
 // This class converts operations to a given conversion target via a set of
 // rewrite patterns. The conversion behaves differently depending on the
 // conversion mode.
 struct OperationConverter {
-  explicit OperationConverter(ConversionTarget &target,
+  explicit OperationConverter(const ConversionTarget &target,
                               const FrozenRewritePatternSet &patterns,
                               OpConversionMode mode,
                               DenseSet<Operation *> *trackedOps = nullptr)
       : opLegalizer(target, patterns), mode(mode), trackedOps(trackedOps) {}
 
   /// Converts the given operations to the conversion target.
   LogicalResult
   convertOperations(ArrayRef<Operation *> ops,
LogicalResult OperationConverter::convert(ConversionPatternRewriter &rewriter,
   return success();
 }
 
 LogicalResult OperationConverter::convertOperations(
     ArrayRef<Operation *> ops,
     function_ref<void(Diagnostic &)> notifyCallback) {
   if (ops.empty())
     return success();
-  ConversionTarget &target = opLegalizer.getTarget();
+  const ConversionTarget &target = opLegalizer.getTarget();
 
   // Compute the set of operations and blocks to convert.
   SmallVector<Operation *> toConvert;
   for (auto *op : ops) {
     op->walk<WalkOrder::PreOrder, ForwardDominanceIterator<>>(
         [&](Operation *op) {
           toConvert.push_back(op);
           // Don't check this operation's children for conversion if the

 // Op Conversion Entry Points
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Partial Conversion
 
 LogicalResult
 mlir::applyPartialConversion(ArrayRef<Operation *> ops,
-                             ConversionTarget &target,
+                             const ConversionTarget &target,
                              const FrozenRewritePatternSet &patterns,
                              DenseSet<Operation *> *unconvertedOps) {
   OperationConverter opConverter(target, patterns, OpConversionMode::Partial,
                                  unconvertedOps);
   return opConverter.convertOperations(ops);
 }
 LogicalResult
-mlir::applyPartialConversion(Operation *op, ConversionTarget &target,
+mlir::applyPartialConversion(Operation *op, const ConversionTarget &target,
                              const FrozenRewritePatternSet &patterns,
                              DenseSet<Operation *> *unconvertedOps) {
   return applyPartialConversion(llvm::ArrayRef(op), target, patterns,
                                 unconvertedOps);
 }
 
 //===----------------------------------------------------------------------===//
 // Full Conversion
 
 LogicalResult
-mlir::applyFullConversion(ArrayRef<Operation *> ops, ConversionTarget &target,
+mlir::applyFullConversion(ArrayRef<Operation *> ops, const ConversionTarget &target,
                           const FrozenRewritePatternSet &patterns) {
   OperationConverter opConverter(target, patterns, OpConversionMode::Full);
   return opConverter.convertOperations(ops);
 }
 LogicalResult
-mlir::applyFullConversion(Operation *op, ConversionTarget &target,
+mlir::applyFullConversion(Operation *op, const ConversionTarget &target,
                           const FrozenRewritePatternSet &patterns) {
   return applyFullConversion(llvm::ArrayRef(op), target, patterns);
 }
 
 //===----------------------------------------------------------------------===//
 // Analysis Conversion
 
 LogicalResult