}
Expected<ExpressionValue> NumericVariableUse::eval() const {
- Optional<ExpressionValue> Value = Variable->getValue();
+ std::optional<ExpressionValue> Value = Variable->getValue();
if (Value)
return *Value;
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)
}
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(
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,
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)
}
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("("));
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())
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<std::optional<binop_eval_t>>(FuncName)
.Case("add", operator+)
.Case("div", operator/)
.Case("max", max)
}
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();
// 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,
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;
// 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,
#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>
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) {}
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;
}
/// \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
/// 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.
/// 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.
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)) {}
/// 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
/// 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
/// 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
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
/// 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
/// 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);
};
//===----------------------------------------------------------------------===//
projects / platform / upstream / llvm.git / commitdiff