Demo fix for readability-const-return-type (WIP)

[mehdi_amini]

Full repo run

mlir/include/mlir/Dialect/Quant/UniformSupport.h

 /// (i.e. f32, bf16, etc) or a vector/tensor type based on a supported
 /// elemental type.
 ///
 /// Since conversion often involves introspecting some attributes of the
 /// input type in order to determine how to represent it, this is a two step
 /// process.
 struct ExpressedToQuantizedConverter {
   /// Creates a converter for the given input type.
-  static const ExpressedToQuantizedConverter forInputType(Type inputType);
+  static ExpressedToQuantizedConverter forInputType(Type inputType);
 
   /// Converts the inputType to be based on the given elemental type,
   /// returning the new type (or nullptr and emit an error on failure).
   Type convert(QuantizedType elementalType) const;
 
   /// Whether the conversion is legal.
   explicit operator bool() const { return (bool)expressedType; }
 

mlir/include/mlir/TableGen/Predicate.h

public:
 
   // Get the predicate condition.
   std::string getConditionImpl() const;
 
   // Get the definition of the combiner used in this predicate.
   const llvm::Record *getCombinerDef() const;
 
   // Get the predicates that are combined by this predicate.
-  const std::vector<llvm::Record *> getChildren() const;
+  std::vector<llvm::Record *> getChildren() const;
 };
 
 // A combined predicate that requires all child predicates of 'CPred' type to
 // have their expression rewritten with a simple string substitution rule.
 class SubstLeavesPred : public CombinedPred {
 public:
   // Get the replacement pattern.
   StringRef getPattern() const;

mlir/lib/Dialect/Quant/Utils/UniformSupport.cpp

 
 using namespace mlir;
 using namespace mlir::quant;
 
 static bool isQuantizablePrimitiveType(Type inputType) {
   return inputType.isa<FloatType>();
 }
 
-const ExpressedToQuantizedConverter
+ExpressedToQuantizedConverter
 ExpressedToQuantizedConverter::forInputType(Type inputType) {
   if (inputType.isa<TensorType, VectorType>()) {
     Type elementType = inputType.cast<ShapedType>().getElementType();
     if (!isQuantizablePrimitiveType(elementType))
       return ExpressedToQuantizedConverter{inputType, nullptr};
     return ExpressedToQuantizedConverter{inputType, elementType};
   }
   // Supported primitive type (which just is the expressed type).

mlir/lib/TableGen/Predicate.cpp

assert((!def || def->isSubClassOf("CombinedPred")) &&
          "must be a subclass of Tablegen 'CombinedPred' class");
 }
 
 const llvm::Record *CombinedPred::getCombinerDef() const {
   assert(def->getValue("kind") && "CombinedPred must have a value 'kind'");
   return def->getValueAsDef("kind");
 }
 
-const std::vector<llvm::Record *> CombinedPred::getChildren() const {
+std::vector<llvm::Record *> CombinedPred::getChildren() const {
   assert(def->getValue("children") &&
          "CombinedPred must have a value 'children'");
   return def->getValueAsListOfDefs("children");
 }
 
 namespace {
 // Kinds of nodes in a logical predicate tree.
 enum class PredCombinerKind {