[mlir][affineexpr] Changing `AsmParser::parseAffineExpr` API to use ArrayRef

[wrengr]

Summary

The methods added by D154177 don't require the symbolSet parameter to be mutable nor to have the SmallVectorImpl type, so this commit changes them to accept ArrayRef instead: both for generality, and to make the non-mutation an explicit part of the API.

[wrengr]

git-clang-format

mlir/include/mlir/IR/OpImplementation.h

public:
   parseOptionalAttrDictWithKeyword(NamedAttrList &result) = 0;
 
   /// Parse an affine map instance into 'map'.
   virtual ParseResult parseAffineMap(AffineMap &map) = 0;
 
   /// Parse an affine expr instance into 'expr' using the already computed
   /// mapping from symbols to affine expressions in 'symbolSet'.
   virtual ParseResult
-  parseAffineExpr(SmallVectorImpl<std::pair<StringRef, AffineExpr>> &symbolSet,
+  parseAffineExpr(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
                   AffineExpr &expr) = 0;
 
   /// Parse an integer set instance into 'set'.
   virtual ParseResult parseIntegerSet(IntegerSet &set) = 0;
 
   //===--------------------------------------------------------------------===//
   // Identifier Parsing
   //===--------------------------------------------------------------------===//

mlir/lib/AsmParser/AffineParser.cpp

public:
   AffineParser(ParserState &state, bool allowParsingSSAIds = false,
                function_ref<ParseResult(bool)> parseElement = nullptr)
       : Parser(state), allowParsingSSAIds(allowParsingSSAIds),
         parseElement(parseElement) {}
 
   ParseResult parseAffineMapRange(unsigned numDims, unsigned numSymbols,
                                   AffineMap &result);
   ParseResult parseAffineMapOrIntegerSetInline(AffineMap &map, IntegerSet &set);
-  ParseResult parseAffineExprInline(
-      SmallVectorImpl<std::pair<StringRef, AffineExpr>> &symbolSet,
+  ParseResult
+  parseAffineExprInline(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
                         AffineExpr &expr);
   ParseResult parseIntegerSetConstraints(unsigned numDims, unsigned numSymbols,
                                          IntegerSet &result);
   ParseResult parseAffineMapOfSSAIds(AffineMap &map,
                                      OpAsmParser::Delimiter delimiter);
   ParseResult parseAffineExprOfSSAIds(AffineExpr &expr);
 
 private:
   // Binary affine op parsing.
ParseResult AffineParser::parseAffineMapOrIntegerSetInline(AffineMap &map,
 
   if (parseToken(Token::colon, "expected '->' or ':'"))
     return failure();
   return parseIntegerSetConstraints(numDims, numSymbols, set);
 }
 
 /// Parse an affine expresion definition inline, with given symbols.
 ParseResult AffineParser::parseAffineExprInline(
-    SmallVectorImpl<std::pair<StringRef, AffineExpr>> &symbolSet,
-    AffineExpr &expr) {
-  dimsAndSymbols.assign(symbolSet);
+    ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet, AffineExpr &expr) {
+  dimsAndSymbols.assign(symbolSet.begin(), symbolSet.end());
   expr = parseAffineExpr();
   return success(expr != nullptr);
 }
 
 /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
 ParseResult
 AffineParser::parseAffineMapOfSSAIds(AffineMap &map,
                                      OpAsmParser::Delimiter delimiter) {
ParseResult Parser::parseAffineMapReference(AffineMap &map) {
   IntegerSet set;
   if (parseAffineMapOrIntegerSetReference(map, set))
     return failure();
   if (set)
     return emitError(curLoc, "expected AffineMap, but got IntegerSet");
   return success();
 }
 ParseResult Parser::parseAffineExprReference(
-    SmallVectorImpl<std::pair<StringRef, AffineExpr>> &symbolSet,
-    AffineExpr &expr) {
+    ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet, AffineExpr &expr) {
   return AffineParser(state).parseAffineExprInline(symbolSet, expr);
 }
 ParseResult Parser::parseIntegerSetReference(IntegerSet &set) {
   SMLoc curLoc = getToken().getLoc();
   AffineMap map;
   if (parseAffineMapOrIntegerSetReference(map, set))
     return failure();
   if (map)

mlir/lib/AsmParser/AsmParserImpl.h

public:
   /// Parse an affine map instance into 'map'.
   ParseResult parseAffineMap(AffineMap &map) override {
     return parser.parseAffineMapReference(map);
   }
 
   /// Parse an affine expr instance into 'expr' using the already computed
   /// mapping from symbols to affine expressions in 'symbolSet'.
   ParseResult
-  parseAffineExpr(SmallVectorImpl<std::pair<StringRef, AffineExpr>> &symbolSet,
+  parseAffineExpr(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
                   AffineExpr &expr) override {
     return parser.parseAffineExprReference(symbolSet, expr);
   }
 
   /// Parse an integer set instance into 'set'.
   ParseResult parseIntegerSet(IntegerSet &set) override {
     return parser.parseIntegerSetReference(set);
   }

mlir/lib/AsmParser/Parser.h

public:
   //===--------------------------------------------------------------------===//
   // Affine Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a reference to either an affine map, expr, or an integer set.
   ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,
                                                   IntegerSet &set);
   ParseResult parseAffineMapReference(AffineMap &map);
-  ParseResult parseAffineExprReference(
-      SmallVectorImpl<std::pair<StringRef, AffineExpr>> &symbolSet,
+  ParseResult
+  parseAffineExprReference(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,
                            AffineExpr &expr);
   ParseResult parseIntegerSetReference(IntegerSet &set);
 
   /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
   ParseResult
   parseAffineMapOfSSAIds(AffineMap &map,
                          function_ref<ParseResult(bool)> parseElement,
                          Delimiter delimiter);