address comments 2

Author: matthias-springer

mlir/lib/AsmParser/AsmParserImpl.h

@@ -287,9 +287,9 @@ class AsmParserImpl : public BaseT {
                          APFloat &result) override {
     bool isNegative = parser.consumeIf(Token::minus);
     Token curTok = parser.getToken();
-    FailureOr<APFloat> apResult =
-        parser.parseFloatFromLiteral(curTok, isNegative, semantics);
-    if (failed(apResult))
+    std::optional<APFloat> apResult;
+    if (failed(parser.parseFloatFromLiteral(apResult, curTok, isNegative,
+                                            semantics)))
       return failure();
     parser.consumeToken();
     result = *apResult;

mlir/lib/AsmParser/AttributeParser.cpp

@@ -422,9 +422,9 @@ Attribute Parser::parseDecOrHexAttr(Type type, bool isNegative) {
   }
 
   if (auto floatType = dyn_cast<FloatType>(type)) {
-    FailureOr<APFloat> result = parseFloatFromIntegerLiteral(
-        tok, isNegative, floatType.getFloatSemantics());
-    if (failed(result))
+    std::optional<APFloat> result;
+    if (failed(parseFloatFromIntegerLiteral(result, tok, isNegative,
+                                            floatType.getFloatSemantics())))
       return Attribute();
     return FloatAttr::get(floatType, *result);
   }
@@ -657,9 +657,9 @@ TensorLiteralParser::getFloatAttrElements(SMLoc loc, FloatType eltTy,
   for (const auto &signAndToken : storage) {
     bool isNegative = signAndToken.first;
     const Token &token = signAndToken.second;
-    FailureOr<APFloat> result =
-        p.parseFloatFromLiteral(token, isNegative, eltTy.getFloatSemantics());
-    if (failed(result))
+    std::optional<APFloat> result;
+    if (failed(p.parseFloatFromLiteral(result, token, isNegative,
+                                       eltTy.getFloatSemantics())))
       return failure();
     floatValues.push_back(*result);
   }
@@ -880,9 +880,10 @@ ParseResult DenseArrayElementParser::parseIntegerElement(Parser &p) {
 ParseResult DenseArrayElementParser::parseFloatElement(Parser &p) {
   bool isNegative = p.consumeIf(Token::minus);
   Token token = p.getToken();
-  FailureOr<APFloat> fromIntLit = p.parseFloatFromLiteral(
-      token, isNegative, cast<FloatType>(type).getFloatSemantics());
-  if (failed(fromIntLit))
+  std::optional<APFloat> fromIntLit;
+  if (failed(
+          p.parseFloatFromLiteral(fromIntLit, token, isNegative,
+                                  cast<FloatType>(type).getFloatSemantics())))
     return failure();
   p.consumeToken();
   append(fromIntLit->bitcastToAPInt());

mlir/lib/AsmParser/Parser.cpp

@@ -347,59 +347,59 @@ OptionalParseResult Parser::parseOptionalDecimalInteger(APInt &result) {
   return success();
 }
 
-FailureOr<APFloat>
-Parser::parseFloatFromLiteral(const Token &tok, bool isNegative,
-                              const llvm::fltSemantics &semantics) {
+ParseResult Parser::parseFloatFromLiteral(std::optional<APFloat> &result,
+                                          const Token &tok, bool isNegative,
+                                          const llvm::fltSemantics &semantics) {
   // Check for a floating point value.
   if (tok.is(Token::floatliteral)) {
     auto val = tok.getFloatingPointValue();
     if (!val)
       return emitError(tok.getLoc()) << "floating point value too large";
 
-    APFloat result(isNegative ? -*val : *val);
+    result.emplace(isNegative ? -*val : *val);
     bool unused;
-    result.convert(semantics, APFloat::rmNearestTiesToEven, &unused);
-    return result;
+    result->convert(semantics, APFloat::rmNearestTiesToEven, &unused);
+    return success();
   }
 
   // Check for a hexadecimal float value.
   if (tok.is(Token::integer))
-    return parseFloatFromIntegerLiteral(tok, isNegative, semantics);
+    return parseFloatFromIntegerLiteral(result, tok, isNegative, semantics);
 
   return emitError(tok.getLoc()) << "expected floating point literal";
 }
 
 /// Parse a floating point value from an integer literal token.
-FailureOr<APFloat>
-Parser::parseFloatFromIntegerLiteral(const Token &tok, bool isNegative,
+ParseResult
+Parser::parseFloatFromIntegerLiteral(std::optional<APFloat> &result,
+                                     const Token &tok, bool isNegative,
                                      const llvm::fltSemantics &semantics) {
   StringRef spelling = tok.getSpelling();
   bool isHex = spelling.size() > 1 && spelling[1] == 'x';
   if (!isHex) {
-    auto error = emitError(tok.getLoc());
-    error << "unexpected decimal integer literal for a "
-             "floating point value";
-    error.attachNote() << "add a trailing dot to make the literal a float";
-    return failure();
+    return emitError(tok.getLoc(), "unexpected decimal integer literal for a "
+                                   "floating point value")
+               .attachNote()
+           << "add a trailing dot to make the literal a float";
   }
   if (isNegative) {
-    emitError(tok.getLoc()) << "hexadecimal float literal should not have a "
-                               "leading minus";
-    return failure();
+    return emitError(tok.getLoc(),
+                     "hexadecimal float literal should not have a "
+                     "leading minus");
   }
 
   APInt intValue;
   tok.getSpelling().getAsInteger(isHex ? 0 : 10, intValue);
   auto typeSizeInBits = APFloat::semanticsSizeInBits(semantics);
   if (intValue.getActiveBits() > typeSizeInBits) {
-    return emitError(tok.getLoc())
-           << "hexadecimal float constant out of range for type";
-    return failure();
+    return emitError(tok.getLoc(),
+                     "hexadecimal float constant out of range for type");
   }
 
   APInt truncatedValue(typeSizeInBits, intValue.getNumWords(),
                        intValue.getRawData());
-  return APFloat(semantics, truncatedValue);
+  result.emplace(semantics, truncatedValue);
+  return success();
 }
 
 ParseResult Parser::parseOptionalKeyword(StringRef *keyword) {

mlir/lib/AsmParser/Parser.h

@@ -153,13 +153,14 @@ class Parser {
   OptionalParseResult parseOptionalDecimalInteger(APInt &result);
 
   /// Parse a floating point value from a literal.
-  FailureOr<APFloat> parseFloatFromLiteral(const Token &tok, bool isNegative,
-                                           const llvm::fltSemantics &semantics);
+  ParseResult parseFloatFromLiteral(std::optional<APFloat> &result,
+                                    const Token &tok, bool isNegative,
+                                    const llvm::fltSemantics &semantics);
 
   /// Parse a floating point value from an integer literal token.
-  FailureOr<APFloat>
-  parseFloatFromIntegerLiteral(const Token &tok, bool isNegative,
-                               const llvm::fltSemantics &semantics);
+  ParseResult parseFloatFromIntegerLiteral(std::optional<APFloat> &result,
+                                           const Token &tok, bool isNegative,
+                                           const llvm::fltSemantics &semantics);
 
   /// Returns true if the current token corresponds to a keyword.
   bool isCurrentTokenAKeyword() const {