[mlir] Add `const` qualifiers to `AffineMap` methods

[vinograd47]

Summary

The AffineMap class follows the same semantic as Type and Attribute.
It is immutable object, so it make sence to mark its methods as const.
Also part of its API is already marked as const, this change just make the API consistent.

[ftynse]

https://mlir.llvm.org/docs/Rationale/UsageOfConst/

AffineMaps are wrappers around a pointer and are passed by-value (I systematically complain about const AffineMap &), so we don't care about const for them.

[vinograd47]

@ftynse Here is the code snippet, which doesn't work for me:

if (memref.getAffineMaps().front().isPermutation()) {...}

The MemRefType::getAffineMaps returns ArrayRef, which returns const references to its elements. Also some of the methods in AffineMap already marked as const. The change just makes its API consistent.

I've seen this article about const correctness, but as I understood, it applies to Operations, not to Types and Attributes, which are immutable by their nature. And it seems that AffineMap also follows this immutable immortal singleton model as Types and Attributes. Am I wrong?

[ftynse]

Type analogy makes sense. Please put it in the commit description.

[vinograd47]

@ftynse Done

mlir/include/mlir/IR/AffineMap.h

public:
   /// symbols as the largest symbol in `exprs`.
   static SmallVector<AffineMap, 4>
   inferFromExprList(ArrayRef<ArrayRef<AffineExpr>> exprsList);
   static SmallVector<AffineMap, 4>
   inferFromExprList(ArrayRef<SmallVector<AffineExpr, 4>> exprsList);
 
   MLIRContext *getContext() const;
 
-  explicit operator bool() { return map != nullptr; }
+  explicit operator bool() const { return map != nullptr; }
   bool operator==(AffineMap other) const { return other.map == map; }
   bool operator!=(AffineMap other) const { return !(other.map == map); }
 
   /// Returns true if this affine map is an identity affine map.
   /// An identity affine map corresponds to an identity affine function on the
   /// dimensional identifiers.
   bool isIdentity() const;
 
public:
   /// The maps are composable, i.e. that the number of AffineDimExpr of `this`
   /// matches the number of results of `map`.
   ///
   /// Example:
   ///   map1: `(d0, d1)[s0, s1] -> (d0 + 1 + s1, d1 - 1 - s0)`
   ///   map2: `(d0)[s0] -> (d0 + s0, d0 - s0)`
   ///   map1.compose(map2):
   ///     `(d0)[s0, s1, s2] -> (d0 + s1 + s2 + 1, d0 - s0 - s2 - 1)`
-  AffineMap compose(AffineMap map);
+  AffineMap compose(AffineMap map) const;
 
   /// Applies composition by the dims of `this` to the integer `values` and
   /// returns the resulting values. `this` must be symbol-less.
-  SmallVector<int64_t, 4> compose(ArrayRef<int64_t> values);
+  SmallVector<int64_t, 4> compose(ArrayRef<int64_t> values) const;
 
   /// Returns true if the AffineMap represents a subset (i.e. a projection) of a
   /// symbol-less permutation map.
-  bool isProjectedPermutation();
+  bool isProjectedPermutation() const;
 
   /// Returns true if the AffineMap represents a symbol-less permutation map.
-  bool isPermutation();
+  bool isPermutation() const;
 
   /// Returns the map consisting of the `resultPos` subset.
-  AffineMap getSubMap(ArrayRef<unsigned> resultPos);
+  AffineMap getSubMap(ArrayRef<unsigned> resultPos) const;
 
   /// Returns the map consisting of the most major `numResults` results.
   /// Returns the null AffineMap if `numResults` == 0.
   /// Returns `*this` if `numResults` >= `this->getNumResults()`.
-  AffineMap getMajorSubMap(unsigned numResults);
+  AffineMap getMajorSubMap(unsigned numResults) const;
 
   /// Returns the map consisting of the most minor `numResults` results.
   /// Returns the null AffineMap if `numResults` == 0.
   /// Returns `*this` if `numResults` >= `this->getNumResults()`.
-  AffineMap getMinorSubMap(unsigned numResults);
+  AffineMap getMinorSubMap(unsigned numResults) const;
 
   friend ::llvm::hash_code hash_value(AffineMap arg);
 
   /// Methods supporting C API.
   const void *getAsOpaquePointer() const {
     return static_cast<const void *>(map);
   }
   static AffineMap getFromOpaquePointer(const void *pointer) {

mlir/lib/IR/AffineMap.cpp

AffineMap AffineMap::replace(const DenseMap<AffineExpr, AffineExpr> &map,
                              unsigned numResultSyms) const {
   SmallVector<AffineExpr, 4> newResults;
   newResults.reserve(getNumResults());
   for (AffineExpr e : getResults())
     newResults.push_back(e.replace(map));
   return AffineMap::get(numResultDims, numResultSyms, newResults, getContext());
 }
 
-AffineMap AffineMap::compose(AffineMap map) {
+AffineMap AffineMap::compose(AffineMap map) const {
   assert(getNumDims() == map.getNumResults() && "Number of results mismatch");
   // Prepare `map` by concatenating the symbols and rewriting its exprs.
   unsigned numDims = map.getNumDims();
   unsigned numSymbolsThisMap = getNumSymbols();
   unsigned numSymbols = numSymbolsThisMap + map.getNumSymbols();
   SmallVector<AffineExpr, 8> newDims(numDims);
   for (unsigned idx = 0; idx < numDims; ++idx) {
     newDims[idx] = getAffineDimExpr(idx, getContext());
   }
   SmallVector<AffineExpr, 8> newSymbols(numSymbols - numSymbolsThisMap);
   for (unsigned idx = numSymbolsThisMap; idx < numSymbols; ++idx) {
     newSymbols[idx - numSymbolsThisMap] =
         getAffineSymbolExpr(idx, getContext());
   }
   auto newMap =
       map.replaceDimsAndSymbols(newDims, newSymbols, numDims, numSymbols);
   SmallVector<AffineExpr, 8> exprs;
   exprs.reserve(getResults().size());
   for (auto expr : getResults())
     exprs.push_back(expr.compose(newMap));
   return AffineMap::get(numDims, numSymbols, exprs, map.getContext());
 }
 
-SmallVector<int64_t, 4> AffineMap::compose(ArrayRef<int64_t> values) {
+SmallVector<int64_t, 4> AffineMap::compose(ArrayRef<int64_t> values) const {
   assert(getNumSymbols() == 0 && "Expected symbol-less map");
   SmallVector<AffineExpr, 4> exprs;
   exprs.reserve(values.size());
   MLIRContext *ctx = getContext();
   for (auto v : values)
     exprs.push_back(getAffineConstantExpr(v, ctx));
   auto resMap = compose(AffineMap::get(0, 0, exprs, ctx));
   SmallVector<int64_t, 4> res;
   res.reserve(resMap.getNumResults());
   for (auto e : resMap.getResults())
     res.push_back(e.cast<AffineConstantExpr>().getValue());
   return res;
 }
 
-bool AffineMap::isProjectedPermutation() {
+bool AffineMap::isProjectedPermutation() const {
   if (getNumSymbols() > 0)
     return false;
   SmallVector<bool, 8> seen(getNumInputs(), false);
   for (auto expr : getResults()) {
     if (auto dim = expr.dyn_cast<AffineDimExpr>()) {
       if (seen[dim.getPosition()])
         return false;
       seen[dim.getPosition()] = true;
       continue;
     }
     return false;
   }
   return true;
 }
 
-bool AffineMap::isPermutation() {
+bool AffineMap::isPermutation() const {
   if (getNumDims() != getNumResults())
     return false;
   return isProjectedPermutation();
 }
 
-AffineMap AffineMap::getSubMap(ArrayRef<unsigned> resultPos) {
+AffineMap AffineMap::getSubMap(ArrayRef<unsigned> resultPos) const {
   SmallVector<AffineExpr, 4> exprs;
   exprs.reserve(resultPos.size());
   for (auto idx : resultPos)
     exprs.push_back(getResult(idx));
   return AffineMap::get(getNumDims(), getNumSymbols(), exprs, getContext());
 }
 
-AffineMap AffineMap::getMajorSubMap(unsigned numResults) {
+AffineMap AffineMap::getMajorSubMap(unsigned numResults) const {
   if (numResults == 0)
     return AffineMap();
   if (numResults > getNumResults())
     return *this;
   return getSubMap(llvm::to_vector<4>(llvm::seq<unsigned>(0, numResults)));
 }
 
-AffineMap AffineMap::getMinorSubMap(unsigned numResults) {
+AffineMap AffineMap::getMinorSubMap(unsigned numResults) const {
   if (numResults == 0)
     return AffineMap();
   if (numResults > getNumResults())
     return *this;
   return getSubMap(llvm::to_vector<4>(
       llvm::seq<unsigned>(getNumResults() - numResults, getNumResults())));
 }