[FileCheck] llvm::Optional => std::optional

1 files changed, 21 insertions, 21 deletions

diff --git a/llvm/lib/FileCheck/FileCheckImpl.h b/llvm/lib/FileCheck/FileCheckImpl.h
index 556be6b..fd3568e 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>
 
@@ -266,23 +266,23 @@ private:
   ExpressionFormat ImplicitFormat;
 
   /// Value of numeric variable, if defined, or std::nullopt otherwise.
-  Optional<ExpressionValue> Value;
+  std::optional<ExpressionValue> Value;
 
   /// The input buffer's string from which Value was parsed, or std::nullopt.
   /// See comments on getStringValue for a discussion of the None case.
-  Optional<StringRef> StrValue;
+  std::optional<StringRef> StrValue;
 
   /// 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.
-  Optional<size_t> DefLineNumber;
+  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 = std::nullopt)
+                           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 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 = std::nullopt) {
+                std::optional<StringRef> NewStrValue = std::nullopt) {
     Value = NewValue;
     StrValue = NewStrValue;
   }
@@ -320,7 +320,7 @@ public:
 
   /// \returns the line number where this variable is defined, if any, or
   /// std::nullopt if defined before input is parsed.
-  Optional<size_t> getDefLineNumber() const { return DefLineNumber; }
+  std::optional<size_t> getDefLineNumber() const { return DefLineNumber; }
 };
 
 /// Class representing the use of a numeric variable in the AST of an
@@ -675,14 +675,14 @@ class Pattern {
   /// 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.
-  Optional<size_t> LineNumber;
+  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 = std::nullopt)
+          std::optional<size_t> Line = std::nullopt)
       : Context(Context), CheckTy(Ty), LineNumber(Line) {}
 
   /// \returns the location in source code.
@@ -719,8 +719,8 @@ public:
   /// representing the numeric variable defined in this numeric substitution
   /// 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);
 };
 
 //===----------------------------------------------------------------------===//