[mlir] Update DialectAsmParser::parseString to use std::string instead of StringRef

[rriddle]

Summary

This allows for parsing strings that have escape sequences, which require constructing
a string (as they can't be represented by looking at the Token contents directly).

Depends On D108586

[rriddle]

update

[jpienaar]

OOC why can't they be represented as a token? (I'm assuming as we need to differentiate at higher level than where token is constructed but could be wrong)

[rriddle]

In D108589#2961463, @jpienaar wrote:

OOC why can't they be represented as a token? (I'm assuming as we need to differentiate at higher level than where token is constructed but could be wrong)

They are represented as tokens, but we can't use the raw token value as the string (like we currently are). E.g. we \22foo\22 is not the same as "foo".

mlir/include/mlir/IR/DialectImplementation.h

OptionalParseResult parseOptionalInteger(IntT &result) {
     return success();
   }
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
-  T getChecked(llvm::SMLoc loc, ParamsT &&... params) {
+  T getChecked(llvm::SMLoc loc, ParamsT &&...params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
   /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
   /// errors.
   template <typename T, typename... ParamsT>
-  T getChecked(ParamsT &&... params) {
+  T getChecked(ParamsT &&...params) {
     return T::getChecked([&] { return emitError(getNameLoc()); },
                          std::forward<ParamsT>(params)...);
   }
 
   //===--------------------------------------------------------------------===//
   // Token Parsing
   //===--------------------------------------------------------------------===//
 
public:
 
   /// Parse a `=` token.
   virtual ParseResult parseEqual() = 0;
 
   /// Parse a `=` token if present.
   virtual ParseResult parseOptionalEqual() = 0;
 
   /// Parse a quoted string token.
-  ParseResult parseString(StringRef *string) {
+  ParseResult parseString(std::string *string) {
     auto loc = getCurrentLocation();
     if (parseOptionalString(string))
       return emitError(loc, "expected string");
     return success();
   }
 
   /// Parse a quoted string token if present.
-  virtual ParseResult parseOptionalString(StringRef *string) = 0;
+  virtual ParseResult parseOptionalString(std::string *string) = 0;
 
   /// Parse a given keyword.
   ParseResult parseKeyword(StringRef keyword, const Twine &msg = "") {
     auto loc = getCurrentLocation();
     if (parseOptionalKeyword(keyword))
       return emitError(loc, "expected '") << keyword << "'" << msg;
     return success();
   }

mlir/lib/Dialect/DLTI/DLTI.cpp

 
 /// Parses an attribute with syntax:
 ///   attr ::= `#target.` `dl_entry` `<` (type | quoted-string) `,` attr `>`
 DataLayoutEntryAttr DataLayoutEntryAttr::parse(DialectAsmParser &parser) {
   if (failed(parser.parseLess()))
     return {};
 
   Type type = nullptr;
-  StringRef identifier;
+  std::string identifier;
   llvm::SMLoc idLoc = parser.getCurrentLocation();
   OptionalParseResult parsedType = parser.parseOptionalType(type);
   if (parsedType.hasValue() && failed(parsedType.getValue()))
     return {};
   if (!parsedType.hasValue()) {
     OptionalParseResult parsedString = parser.parseOptionalString(&identifier);
     if (!parsedString.hasValue() || failed(parsedString.getValue())) {
       parser.emitError(idLoc) << "expected a type or a quoted string";

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCAttributes.cpp.inc"
 
 Attribute emitc::OpaqueAttr::parse(MLIRContext *context,
                                    DialectAsmParser &parser, Type type) {
   if (parser.parseLess())
     return Attribute();
-  StringRef value;
+  std::string value;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value)) {
     parser.emitError(loc) << "expected string";
     return Attribute();
   }
   if (parser.parseGreater())
     return Attribute();
   return get(context, value);

 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
 #include "mlir/Dialect/EmitC/IR/EmitCTypes.cpp.inc"
 
 Type emitc::OpaqueType::parse(MLIRContext *context, DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
-  StringRef value;
+  std::string value;
   llvm::SMLoc loc = parser.getCurrentLocation();
   if (parser.parseOptionalString(&value) || value.empty()) {
     parser.emitError(loc) << "expected non empty string";
     return Type();
   }
   if (parser.parseGreater())
     return Type();
   return get(context, value);

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

if (parser.parseDimensionList(shape, /*allowDynamic=*/false) ||
         parser.parseType(elementType))
       return nullptr;
 
     // Parse ','
     if (parser.parseComma())
       return nullptr;
 
     // Parse operand.
-    StringRef operand;
+    std::string operand;
     if (failed(parser.parseOptionalString(&operand)))
       return nullptr;
 
     // Parse '>'.
     if (parser.parseGreater())
       return nullptr;
 
     return MMAMatrixType::getChecked(mlir::detail::getDefaultDiagnosticEmitFn(

mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp

static LLVMStructType parseStructType(DialectAsmParser &parser) {
   Location loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
 
   if (failed(parser.parseLess()))
     return LLVMStructType();
 
   // If we are parsing a self-reference to a recursive struct, i.e. the parsing
   // stack already contains a struct with the same identifier, bail out after
   // the name.
-  StringRef name;
+  std::string name;
   bool isIdentified = succeeded(parser.parseOptionalString(&name));
   if (isIdentified) {
     if (knownStructNames.count(name)) {
       if (failed(parser.parseGreater()))
         return LLVMStructType();
       return LLVMStructType::getIdentifiedChecked(
           [loc] { return emitError(loc); }, loc.getContext(), name);
     }

mlir/lib/Parser/DialectSymbolParser.cpp

public:
   }
 
   /// Parses a '*' if present.
   ParseResult parseOptionalStar() override {
     return success(parser.consumeIf(Token::star));
   }
 
   /// Parses a quoted string token if present.
-  ParseResult parseOptionalString(StringRef *string) override {
+  ParseResult parseOptionalString(std::string *string) override {
     if (!parser.getToken().is(Token::string))
       return failure();
 
     if (string)
-      *string = parser.getTokenSpelling().drop_front().drop_back();
+      *string = parser.getToken().getStringValue();
     parser.consumeToken();
     return success();
   }
 
   /// Returns true if the current token corresponds to a keyword.
   bool isCurrentTokenAKeyword() const {
     return parser.getToken().is(Token::bare_identifier) ||
            parser.getToken().isKeyword();