vendor/llvm-project/llvmorg-16-init-18548-gb0daacf58f41

2 files changed, 62 insertions, 61 deletions

diff --git a/llvm/lib/FileCheck/FileCheck.cpp b/llvm/lib/FileCheck/FileCheck.cpp
index 5d4cfceefb3e..ec963c2de45b 100644
--- a/llvm/lib/FileCheck/FileCheck.cpp
+++ b/llvm/lib/FileCheck/FileCheck.cpp
@@ -206,7 +206,7 @@ Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand,
   if (LeftOperand.isNegative() && RightOperand.isNegative()) {
     int64_t LeftValue = cantFail(LeftOperand.getSignedValue());
     int64_t RightValue = cantFail(RightOperand.getSignedValue());
-    Optional<int64_t> Result = checkedAdd<int64_t>(LeftValue, RightValue);
+    std::optional<int64_t> Result = checkedAdd<int64_t>(LeftValue, RightValue);
     if (!Result)
       return make_error<OverflowError>();
 
@@ -224,7 +224,7 @@ Expected<ExpressionValue> llvm::operator+(const ExpressionValue &LeftOperand,
   // Both values are positive at this point.
   uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
   uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-  Optional<uint64_t> Result =
+  std::optional<uint64_t> Result =
       checkedAddUnsigned<uint64_t>(LeftValue, RightValue);
   if (!Result)
     return make_error<OverflowError>();
@@ -241,7 +241,7 @@ Expected<ExpressionValue> llvm::operator-(const ExpressionValue &LeftOperand,
     // Result <= -1 - (max int64_t) which overflows on 1- and 2-complement.
     if (RightValue > (uint64_t)std::numeric_limits<int64_t>::max())
       return make_error<OverflowError>();
-    Optional<int64_t> Result =
+    std::optional<int64_t> Result =
         checkedSub(LeftValue, static_cast<int64_t>(RightValue));
     if (!Result)
       return make_error<OverflowError>();
@@ -306,7 +306,7 @@ Expected<ExpressionValue> llvm::operator*(const ExpressionValue &LeftOperand,
   // Result will be positive and can overflow.
   uint64_t LeftValue = cantFail(LeftOperand.getUnsignedValue());
   uint64_t RightValue = cantFail(RightOperand.getUnsignedValue());
-  Optional<uint64_t> Result =
+  std::optional<uint64_t> Result =
       checkedMulUnsigned<uint64_t>(LeftValue, RightValue);
   if (!Result)
     return make_error<OverflowError>();
@@ -363,7 +363,7 @@ Expected<ExpressionValue> llvm::min(const ExpressionValue &LeftOperand,
 }
 
 Expected<ExpressionValue> NumericVariableUse::eval() const {
-  Optional<ExpressionValue> Value = Variable->getValue();
+  std::optional<ExpressionValue> Value = Variable->getValue();
   if (Value)
     return *Value;
 
@@ -480,7 +480,7 @@ char ErrorReported::ID = 0;
 
 Expected<NumericVariable *> Pattern::parseNumericVariableDefinition(
     StringRef &Expr, FileCheckPatternContext *Context,
-    Optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
+    std::optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
     const SourceMgr &SM) {
   Expected<VariableProperties> ParseVarResult = parseVariable(Expr, SM);
   if (!ParseVarResult)
@@ -518,7 +518,7 @@ Expected<NumericVariable *> Pattern::parseNumericVariableDefinition(
 }
 
 Expected<std::unique_ptr<NumericVariableUse>> Pattern::parseNumericVariableUse(
-    StringRef Name, bool IsPseudo, Optional<size_t> LineNumber,
+    StringRef Name, bool IsPseudo, std::optional<size_t> LineNumber,
     FileCheckPatternContext *Context, const SourceMgr &SM) {
   if (IsPseudo && !Name.equals("@LINE"))
     return ErrorDiagnostic::get(
@@ -542,7 +542,7 @@ Expected<std::unique_ptr<NumericVariableUse>> Pattern::parseNumericVariableUse(
     Context->GlobalNumericVariableTable[Name] = NumericVariable;
   }
 
-  Optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();
+  std::optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();
   if (DefLineNumber && LineNumber && *DefLineNumber == *LineNumber)
     return ErrorDiagnostic::get(
         SM, Name,
@@ -554,7 +554,7 @@ Expected<std::unique_ptr<NumericVariableUse>> Pattern::parseNumericVariableUse(
 
 Expected<std::unique_ptr<ExpressionAST>> Pattern::parseNumericOperand(
     StringRef &Expr, AllowedOperand AO, bool MaybeInvalidConstraint,
-    Optional<size_t> LineNumber, FileCheckPatternContext *Context,
+    std::optional<size_t> LineNumber, FileCheckPatternContext *Context,
     const SourceMgr &SM) {
   if (Expr.startswith("(")) {
     if (AO != AllowedOperand::Any)
@@ -611,7 +611,7 @@ Expected<std::unique_ptr<ExpressionAST>> Pattern::parseNumericOperand(
 }
 
 Expected<std::unique_ptr<ExpressionAST>>
-Pattern::parseParenExpr(StringRef &Expr, Optional<size_t> LineNumber,
+Pattern::parseParenExpr(StringRef &Expr, std::optional<size_t> LineNumber,
                         FileCheckPatternContext *Context, const SourceMgr &SM) {
   Expr = Expr.ltrim(SpaceChars);
   assert(Expr.startswith("("));
@@ -646,7 +646,7 @@ Pattern::parseParenExpr(StringRef &Expr, Optional<size_t> LineNumber,
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
                     std::unique_ptr<ExpressionAST> LeftOp,
-                    bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+                    bool IsLegacyLineExpr, std::optional<size_t> LineNumber,
                     FileCheckPatternContext *Context, const SourceMgr &SM) {
   RemainingExpr = RemainingExpr.ltrim(SpaceChars);
   if (RemainingExpr.empty())
@@ -690,19 +690,19 @@ Pattern::parseBinop(StringRef Expr, StringRef &RemainingExpr,
 
 Expected<std::unique_ptr<ExpressionAST>>
 Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName,
-                       Optional<size_t> LineNumber,
+                       std::optional<size_t> LineNumber,
                        FileCheckPatternContext *Context, const SourceMgr &SM) {
   Expr = Expr.ltrim(SpaceChars);
   assert(Expr.startswith("("));
 
-  auto OptFunc = StringSwitch<Optional<binop_eval_t>>(FuncName)
+  auto OptFunc = StringSwitch<binop_eval_t>(FuncName)
                      .Case("add", operator+)
                      .Case("div", operator/)
                      .Case("max", max)
                      .Case("min", min)
                      .Case("mul", operator*)
                      .Case("sub", operator-)
-                     .Default(None);
+                     .Default(nullptr);
 
   if (!OptFunc)
     return ErrorDiagnostic::get(
@@ -765,12 +765,12 @@ Pattern::parseCallExpr(StringRef &Expr, StringRef FuncName,
 }
 
 Expected<std::unique_ptr<Expression>> Pattern::parseNumericSubstitutionBlock(
-    StringRef Expr, Optional<NumericVariable *> &DefinedNumericVariable,
-    bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+    StringRef Expr, std::optional<NumericVariable *> &DefinedNumericVariable,
+    bool IsLegacyLineExpr, std::optional<size_t> LineNumber,
     FileCheckPatternContext *Context, const SourceMgr &SM) {
   std::unique_ptr<ExpressionAST> ExpressionASTPointer = nullptr;
   StringRef DefExpr = StringRef();
-  DefinedNumericVariable = None;
+  DefinedNumericVariable = std::nullopt;
   ExpressionFormat ExplicitFormat = ExpressionFormat();
   unsigned Precision = 0;
 
@@ -1099,7 +1099,7 @@ bool Pattern::parsePattern(StringRef PatternStr, StringRef Prefix,
 
       // Parse numeric substitution block.
       std::unique_ptr<Expression> ExpressionPointer;
-      Optional<NumericVariable *> DefinedNumericVariable;
+      std::optional<NumericVariable *> DefinedNumericVariable;
       if (IsNumBlock) {
         Expected<std::unique_ptr<Expression>> ParseResult =
             parseNumericSubstitutionBlock(MatchStr, DefinedNumericVariable,
@@ -1412,7 +1412,7 @@ void Pattern::printVariableDefs(const SourceMgr &SM,
   for (const auto &VariableDef : NumericVariableDefs) {
     VarCapture VC;
     VC.Name = VariableDef.getKey();
-    Optional<StringRef> StrValue =
+    std::optional<StringRef> StrValue =
         VariableDef.getValue().DefinedNumericVariable->getStringValue();
     if (!StrValue)
       continue;
@@ -2701,10 +2701,11 @@ Error FileCheckPatternContext::defineCmdlineVariables(
       // Now parse the definition both to check that the syntax is correct and
       // to create the necessary class instance.
       StringRef CmdlineDefExpr = CmdlineDef.substr(1);
-      Optional<NumericVariable *> DefinedNumericVariable;
+      std::optional<NumericVariable *> DefinedNumericVariable;
       Expected<std::unique_ptr<Expression>> ExpressionResult =
-          Pattern::parseNumericSubstitutionBlock(
-              CmdlineDefExpr, DefinedNumericVariable, false, None, this, SM);
+          Pattern::parseNumericSubstitutionBlock(CmdlineDefExpr,
+                                                 DefinedNumericVariable, false,
+                                                 std::nullopt, this, SM);
       if (!ExpressionResult) {
         Errs = joinErrors(std::move(Errs), ExpressionResult.takeError());
         continue;
diff --git a/llvm/lib/FileCheck/FileCheckImpl.h b/llvm/lib/FileCheck/FileCheckImpl.h
index 29e721e088d2..fd3568e7a5b0 100644
--- a/llvm/lib/FileCheck/FileCheckImpl.h
+++ b/llvm/lib/FileCheck/FileCheckImpl.h
@@ -15,13 +15,13 @@
 #ifndef LLVM_LIB_FILECHECK_FILECHECKIMPL_H
 #define LLVM_LIB_FILECHECK_FILECHECKIMPL_H
 
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/FileCheck/FileCheck.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/SourceMgr.h"
 #include <map>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -265,24 +265,24 @@ private:
   /// format.
   ExpressionFormat ImplicitFormat;
 
-  /// Value of numeric variable, if defined, or None otherwise.
-  Optional<ExpressionValue> Value;
+  /// Value of numeric variable, if defined, or std::nullopt otherwise.
+  std::optional<ExpressionValue> Value;
 
-  /// The input buffer's string from which Value was parsed, or None.  See
-  /// comments on getStringValue for a discussion of the None case.
-  Optional<StringRef> StrValue;
+  /// The input buffer's string from which Value was parsed, or std::nullopt.
+  /// See comments on getStringValue for a discussion of the None case.
+  std::optional<StringRef> StrValue;
 
-  /// Line number where this variable is defined, or None if defined before
-  /// input is parsed. Used to determine whether a variable is defined on the
-  /// same line as a given use.
-  Optional<size_t> DefLineNumber;
+  /// Line number where this variable is defined, or std::nullopt if defined
+  /// before input is parsed. Used to determine whether a variable is defined on
+  /// the same line as a given use.
+  std::optional<size_t> DefLineNumber;
 
 public:
   /// Constructor for a variable \p Name with implicit format \p ImplicitFormat
   /// defined at line \p DefLineNumber or defined before input is parsed if
   /// \p DefLineNumber is None.
   explicit NumericVariable(StringRef Name, ExpressionFormat ImplicitFormat,
-                           Optional<size_t> DefLineNumber = None)
+                           std::optional<size_t> DefLineNumber = std::nullopt)
       : Name(Name), ImplicitFormat(ImplicitFormat),
         DefLineNumber(DefLineNumber) {}
 
@@ -293,20 +293,20 @@ public:
   ExpressionFormat getImplicitFormat() const { return ImplicitFormat; }
 
   /// \returns this variable's value.
-  Optional<ExpressionValue> getValue() const { return Value; }
+  std::optional<ExpressionValue> getValue() const { return Value; }
 
   /// \returns the input buffer's string from which this variable's value was
-  /// parsed, or None if the value is not yet defined or was not parsed from the
-  /// input buffer.  For example, the value of @LINE is not parsed from the
-  /// input buffer, and some numeric variables are parsed from the command
+  /// parsed, or std::nullopt if the value is not yet defined or was not parsed
+  /// from the input buffer.  For example, the value of @LINE is not parsed from
+  /// the input buffer, and some numeric variables are parsed from the command
   /// line instead.
-  Optional<StringRef> getStringValue() const { return StrValue; }
+  std::optional<StringRef> getStringValue() const { return StrValue; }
 
   /// Sets value of this numeric variable to \p NewValue, and sets the input
   /// buffer string from which it was parsed to \p NewStrValue.  See comments on
   /// getStringValue for a discussion of when the latter can be None.
   void setValue(ExpressionValue NewValue,
-                Optional<StringRef> NewStrValue = None) {
+                std::optional<StringRef> NewStrValue = std::nullopt) {
     Value = NewValue;
     StrValue = NewStrValue;
   }
@@ -314,13 +314,13 @@ public:
   /// Clears value of this numeric variable, regardless of whether it is
   /// currently defined or not.
   void clearValue() {
-    Value = None;
-    StrValue = None;
+    Value = std::nullopt;
+    StrValue = std::nullopt;
   }
 
-  /// \returns the line number where this variable is defined, if any, or None
-  /// if defined before input is parsed.
-  Optional<size_t> getDefLineNumber() const { return DefLineNumber; }
+  /// \returns the line number where this variable is defined, if any, or
+  /// std::nullopt if defined before input is parsed.
+  std::optional<size_t> getDefLineNumber() const { return DefLineNumber; }
 };
 
 /// Class representing the use of a numeric variable in the AST of an
@@ -555,7 +555,7 @@ public:
   SMRange getRange() const { return Range; }
 
   static Error get(const SourceMgr &SM, SMLoc Loc, const Twine &ErrMsg,
-                   SMRange Range = None) {
+                   SMRange Range = std::nullopt) {
     return make_error<ErrorDiagnostic>(
         SM.GetMessage(Loc, SourceMgr::DK_Error, ErrMsg), Range);
   }
@@ -672,17 +672,17 @@ class Pattern {
 
   Check::FileCheckType CheckTy;
 
-  /// Line number for this CHECK pattern or None if it is an implicit pattern.
-  /// Used to determine whether a variable definition is made on an earlier
-  /// line to the one with this CHECK.
-  Optional<size_t> LineNumber;
+  /// Line number for this CHECK pattern or std::nullopt if it is an implicit
+  /// pattern. Used to determine whether a variable definition is made on an
+  /// earlier line to the one with this CHECK.
+  std::optional<size_t> LineNumber;
 
   /// Ignore case while matching if set to true.
   bool IgnoreCase = false;
 
 public:
   Pattern(Check::FileCheckType Ty, FileCheckPatternContext *Context,
-          Optional<size_t> Line = None)
+          std::optional<size_t> Line = std::nullopt)
       : Context(Context), CheckTy(Ty), LineNumber(Line) {}
 
   /// \returns the location in source code.
@@ -717,10 +717,10 @@ public:
   /// holding a diagnostic against \p SM if parsing fails. If substitution was
   /// successful, sets \p DefinedNumericVariable to point to the class
   /// representing the numeric variable defined in this numeric substitution
-  /// block, or None if this block does not define any variable.
+  /// block, or std::nullopt if this block does not define any variable.
   static Expected<std::unique_ptr<Expression>> parseNumericSubstitutionBlock(
-      StringRef Expr, Optional<NumericVariable *> &DefinedNumericVariable,
-      bool IsLegacyLineExpr, Optional<size_t> LineNumber,
+      StringRef Expr, std::optional<NumericVariable *> &DefinedNumericVariable,
+      bool IsLegacyLineExpr, std::optional<size_t> LineNumber,
       FileCheckPatternContext *Context, const SourceMgr &SM);
   /// Parses the pattern in \p PatternStr and initializes this Pattern instance
   /// accordingly.
@@ -736,7 +736,7 @@ public:
     size_t Len;
   };
   struct MatchResult {
-    Optional<Match> TheMatch;
+    std::optional<Match> TheMatch;
     Error TheError;
     MatchResult(size_t MatchPos, size_t MatchLen, Error E)
         : TheMatch(Match{MatchPos, MatchLen}), TheError(std::move(E)) {}
@@ -794,7 +794,7 @@ private:
   /// should defining such a variable be invalid.
   static Expected<NumericVariable *> parseNumericVariableDefinition(
       StringRef &Expr, FileCheckPatternContext *Context,
-      Optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
+      std::optional<size_t> LineNumber, ExpressionFormat ImplicitFormat,
       const SourceMgr &SM);
   /// Parses \p Name as a (pseudo if \p IsPseudo is true) numeric variable use
   /// at line \p LineNumber, or before input is parsed if \p LineNumber is
@@ -803,7 +803,7 @@ private:
   /// representing that variable if successful, or an error holding a
   /// diagnostic against \p SM otherwise.
   static Expected<std::unique_ptr<NumericVariableUse>> parseNumericVariableUse(
-      StringRef Name, bool IsPseudo, Optional<size_t> LineNumber,
+      StringRef Name, bool IsPseudo, std::optional<size_t> LineNumber,
       FileCheckPatternContext *Context, const SourceMgr &SM);
   enum class AllowedOperand { LineVar, LegacyLiteral, Any };
   /// Parses \p Expr for use of a numeric operand at line \p LineNumber, or
@@ -817,7 +817,7 @@ private:
   /// function will attempt to parse a parenthesized expression.
   static Expected<std::unique_ptr<ExpressionAST>>
   parseNumericOperand(StringRef &Expr, AllowedOperand AO, bool ConstraintParsed,
-                      Optional<size_t> LineNumber,
+                      std::optional<size_t> LineNumber,
                       FileCheckPatternContext *Context, const SourceMgr &SM);
   /// Parses and updates \p RemainingExpr for a binary operation at line
   /// \p LineNumber, or before input is parsed if \p LineNumber is None. The
@@ -831,7 +831,7 @@ private:
   static Expected<std::unique_ptr<ExpressionAST>>
   parseBinop(StringRef Expr, StringRef &RemainingExpr,
              std::unique_ptr<ExpressionAST> LeftOp, bool IsLegacyLineExpr,
-             Optional<size_t> LineNumber, FileCheckPatternContext *Context,
+             std::optional<size_t> LineNumber, FileCheckPatternContext *Context,
              const SourceMgr &SM);
 
   /// Parses a parenthesized expression inside \p Expr at line \p LineNumber, or
@@ -841,7 +841,7 @@ private:
   /// variables. \returns the class representing that operand in the AST of the
   /// expression or an error holding a diagnostic against \p SM otherwise.
   static Expected<std::unique_ptr<ExpressionAST>>
-  parseParenExpr(StringRef &Expr, Optional<size_t> LineNumber,
+  parseParenExpr(StringRef &Expr, std::optional<size_t> LineNumber,
                  FileCheckPatternContext *Context, const SourceMgr &SM);
 
   /// Parses \p Expr for an argument list belonging to a call to function \p
@@ -853,8 +853,8 @@ private:
   /// otherwise.
   static Expected<std::unique_ptr<ExpressionAST>>
   parseCallExpr(StringRef &Expr, StringRef FuncName,
-                Optional<size_t> LineNumber, FileCheckPatternContext *Context,
-                const SourceMgr &SM);
+                std::optional<size_t> LineNumber,
+                FileCheckPatternContext *Context, const SourceMgr &SM);
 };
 
 //===----------------------------------------------------------------------===//