[llvm] e15e969 - [FileCheck, 4/4] NFC: Stop using ExpressionValue
Thomas Preud'homme via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 7 09:36:10 PDT 2023
Author: Thomas Preud'homme
Date: 2023-08-07T17:36:05+01:00
New Revision: e15e969a4faca759fe7f0e4ab0f54aed43f98bbc
URL: https://github.com/llvm/llvm-project/commit/e15e969a4faca759fe7f0e4ab0f54aed43f98bbc
DIFF: https://github.com/llvm/llvm-project/commit/e15e969a4faca759fe7f0e4ab0f54aed43f98bbc.diff
LOG: [FileCheck, 4/4] NFC: Stop using ExpressionValue
Use APInt directly instead.
Depends On D150880
Reviewed By: arichardson
Differential Revision: https://reviews.llvm.org/D154430
Added:
Modified:
llvm/lib/FileCheck/FileCheck.cpp
llvm/lib/FileCheck/FileCheckImpl.h
llvm/unittests/FileCheck/FileCheckTest.cpp
Removed:
################################################################################
diff --git a/llvm/lib/FileCheck/FileCheck.cpp b/llvm/lib/FileCheck/FileCheck.cpp
index b344b7176486808..60a0d5982afe90c 100644
--- a/llvm/lib/FileCheck/FileCheck.cpp
+++ b/llvm/lib/FileCheck/FileCheck.cpp
@@ -78,8 +78,7 @@ Expected<std::string> ExpressionFormat::getWildcardRegex() const {
}
Expected<std::string>
-ExpressionFormat::getMatchingString(ExpressionValue IntegerValue) const {
- APInt IntValue = IntegerValue.getAPIntValue();
+ExpressionFormat::getMatchingString(APInt IntValue) const {
if (Value != Kind::Signed && IntValue.isNegative())
return make_error<OverflowError>();
@@ -135,7 +134,7 @@ static APInt toSigned(APInt AbsVal, bool Negative) {
return Result;
}
-Expected<ExpressionValue>
+Expected<APInt>
ExpressionFormat::valueFromStringRepr(StringRef StrVal,
const SourceMgr &SM) const {
bool ValueIsSigned = Value == Kind::Signed;
@@ -155,76 +154,59 @@ ExpressionFormat::valueFromStringRepr(StringRef StrVal,
if (ParseFailure)
return ErrorDiagnostic::get(SM, StrVal,
"unable to represent numeric value");
- return ExpressionValue(toSigned(ResultValue, Negative));
+ return toSigned(ResultValue, Negative);
}
-Expected<ExpressionValue> llvm::exprAdd(const ExpressionValue &LeftOperand,
- const ExpressionValue &RightOperand,
- bool &Overflow) {
- APInt Result = LeftOperand.getAPIntValue().sadd_ov(
- RightOperand.getAPIntValue(), Overflow);
- return ExpressionValue(Result);
+Expected<APInt> llvm::exprAdd(const APInt &LeftOperand,
+ const APInt &RightOperand, bool &Overflow) {
+ return LeftOperand.sadd_ov(RightOperand, Overflow);
}
-Expected<ExpressionValue> llvm::exprSub(const ExpressionValue &LeftOperand,
- const ExpressionValue &RightOperand,
- bool &Overflow) {
- APInt Result = LeftOperand.getAPIntValue().ssub_ov(
- RightOperand.getAPIntValue(), Overflow);
- return ExpressionValue(Result);
+Expected<APInt> llvm::exprSub(const APInt &LeftOperand,
+ const APInt &RightOperand, bool &Overflow) {
+ return LeftOperand.ssub_ov(RightOperand, Overflow);
}
-Expected<ExpressionValue> llvm::exprMul(const ExpressionValue &LeftOperand,
- const ExpressionValue &RightOperand,
- bool &Overflow) {
- APInt Result = LeftOperand.getAPIntValue().smul_ov(
- RightOperand.getAPIntValue(), Overflow);
- return ExpressionValue(Result);
+Expected<APInt> llvm::exprMul(const APInt &LeftOperand,
+ const APInt &RightOperand, bool &Overflow) {
+ return LeftOperand.smul_ov(RightOperand, Overflow);
}
-Expected<ExpressionValue> llvm::exprDiv(const ExpressionValue &LeftOperand,
- const ExpressionValue &RightOperand,
- bool &Overflow) {
+Expected<APInt> llvm::exprDiv(const APInt &LeftOperand,
+ const APInt &RightOperand, bool &Overflow) {
// Check for division by zero.
- if (RightOperand.getAPIntValue().isZero())
+ if (RightOperand.isZero())
return make_error<OverflowError>();
- APInt Result = LeftOperand.getAPIntValue().sdiv_ov(
- RightOperand.getAPIntValue(), Overflow);
- return ExpressionValue(Result);
+ return LeftOperand.sdiv_ov(RightOperand, Overflow);
}
-Expected<ExpressionValue> llvm::exprMax(const ExpressionValue &LeftOperand,
- const ExpressionValue &RightOperand,
- bool &Overflow) {
+Expected<APInt> llvm::exprMax(const APInt &LeftOperand,
+ const APInt &RightOperand, bool &Overflow) {
Overflow = false;
- return LeftOperand.getAPIntValue().slt(RightOperand.getAPIntValue())
- ? RightOperand
- : LeftOperand;
+ return LeftOperand.slt(RightOperand) ? RightOperand : LeftOperand;
}
-Expected<ExpressionValue> llvm::exprMin(const ExpressionValue &LeftOperand,
- const ExpressionValue &RightOperand,
- bool &Overflow) {
+Expected<APInt> llvm::exprMin(const APInt &LeftOperand,
+ const APInt &RightOperand, bool &Overflow) {
Overflow = false;
- if (cantFail(exprMax(LeftOperand, RightOperand, Overflow)).getAPIntValue() ==
- LeftOperand.getAPIntValue())
+ if (cantFail(exprMax(LeftOperand, RightOperand, Overflow)) == LeftOperand)
return RightOperand;
return LeftOperand;
}
-Expected<ExpressionValue> NumericVariableUse::eval() const {
- std::optional<ExpressionValue> Value = Variable->getValue();
+Expected<APInt> NumericVariableUse::eval() const {
+ std::optional<APInt> Value = Variable->getValue();
if (Value)
return *Value;
return make_error<UndefVarError>(getExpressionStr());
}
-Expected<ExpressionValue> BinaryOperation::eval() const {
- Expected<ExpressionValue> MaybeLeftOp = LeftOperand->eval();
- Expected<ExpressionValue> MaybeRightOp = RightOperand->eval();
+Expected<APInt> BinaryOperation::eval() const {
+ Expected<APInt> MaybeLeftOp = LeftOperand->eval();
+ Expected<APInt> MaybeRightOp = RightOperand->eval();
// Bubble up any error (e.g. undefined variables) in the recursive
// evaluation.
@@ -237,8 +219,8 @@ Expected<ExpressionValue> BinaryOperation::eval() const {
return std::move(Err);
}
- APInt LeftOp = MaybeLeftOp->getAPIntValue();
- APInt RightOp = MaybeRightOp->getAPIntValue();
+ APInt LeftOp = *MaybeLeftOp;
+ APInt RightOp = *MaybeRightOp;
bool Overflow;
// Ensure both operands have the same bitwidth.
unsigned LeftBitWidth = LeftOp.getBitWidth();
@@ -247,8 +229,7 @@ Expected<ExpressionValue> BinaryOperation::eval() const {
LeftOp = LeftOp.sext(NewBitWidth);
RightOp = RightOp.sext(NewBitWidth);
do {
- Expected<ExpressionValue> MaybeResult =
- EvalBinop(ExpressionValue(LeftOp), ExpressionValue(RightOp), Overflow);
+ Expected<APInt> MaybeResult = EvalBinop(LeftOp, RightOp, Overflow);
if (!MaybeResult)
return MaybeResult.takeError();
@@ -291,8 +272,7 @@ BinaryOperation::getImplicitFormat(const SourceMgr &SM) const {
Expected<std::string> NumericSubstitution::getResult() const {
assert(ExpressionPointer->getAST() != nullptr &&
"Substituting empty expression");
- Expected<ExpressionValue> EvaluatedValue =
- ExpressionPointer->getAST()->eval();
+ Expected<APInt> EvaluatedValue = ExpressionPointer->getAST()->eval();
if (!EvaluatedValue)
return EvaluatedValue.takeError();
ExpressionFormat Format = ExpressionPointer->getFormat();
@@ -1117,7 +1097,7 @@ Pattern::MatchResult Pattern::match(StringRef Buffer,
TmpStr = RegExStr;
if (LineNumber)
Context->LineVariable->setValue(
- ExpressionValue(APInt(sizeof(*LineNumber) * 8, *LineNumber)));
+ APInt(sizeof(*LineNumber) * 8, *LineNumber));
size_t InsertOffset = 0;
// Substitute all string variables and expressions whose values are only
@@ -1196,8 +1176,7 @@ Pattern::MatchResult Pattern::match(StringRef Buffer,
StringRef MatchedValue = MatchInfo[CaptureParenGroup];
ExpressionFormat Format = DefinedNumericVariable->getImplicitFormat();
- Expected<ExpressionValue> Value =
- Format.valueFromStringRepr(MatchedValue, SM);
+ Expected<APInt> Value = Format.valueFromStringRepr(MatchedValue, SM);
if (!Value)
return MatchResult(TheMatch, Value.takeError());
DefinedNumericVariable->setValue(*Value, MatchedValue);
@@ -2583,7 +2562,7 @@ Error FileCheckPatternContext::defineCmdlineVariables(
// to, since the expression of a command-line variable definition should
// only use variables defined earlier on the command-line. If not, this
// is an error and we report it.
- Expected<ExpressionValue> Value = Expression->getAST()->eval();
+ Expected<APInt> Value = Expression->getAST()->eval();
if (!Value) {
Errs = joinErrors(std::move(Errs), Value.takeError());
continue;
diff --git a/llvm/lib/FileCheck/FileCheckImpl.h b/llvm/lib/FileCheck/FileCheckImpl.h
index ff87a1eea40b932..f5f8ea2ab856ba7 100644
--- a/llvm/lib/FileCheck/FileCheckImpl.h
+++ b/llvm/lib/FileCheck/FileCheckImpl.h
@@ -32,8 +32,6 @@ namespace llvm {
// Numeric substitution handling code.
//===----------------------------------------------------------------------===//
-class ExpressionValue;
-
/// Type representing the format an expression value should be textualized into
/// for matching. Used to represent both explicit format specifiers as well as
/// implicit format from using numeric variables.
@@ -95,14 +93,14 @@ struct ExpressionFormat {
/// \returns the string representation of \p Value in the format represented
/// by this instance, or an error if conversion to this format failed or the
/// format is NoFormat.
- Expected<std::string> getMatchingString(ExpressionValue Value) const;
+ Expected<std::string> getMatchingString(APInt Value) const;
/// \returns the value corresponding to string representation \p StrVal
/// according to the matching format represented by this instance or an error
/// with diagnostic against \p SM if \p StrVal does not correspond to a valid
/// and representable value.
- Expected<ExpressionValue> valueFromStringRepr(StringRef StrVal,
- const SourceMgr &SM) const;
+ Expected<APInt> valueFromStringRepr(StringRef StrVal,
+ const SourceMgr &SM) const;
};
/// Class to represent an overflow error that might result when manipulating a
@@ -118,31 +116,14 @@ class OverflowError : public ErrorInfo<OverflowError> {
void log(raw_ostream &OS) const override { OS << "overflow error"; }
};
-/// Class representing a numeric value.
-class ExpressionValue {
-private:
- APInt Value;
-
-public:
- ExpressionValue(APInt Val) : Value(Val) {}
-
- APInt getAPIntValue() const { return Value; }
-};
-
/// Performs operation and \returns its result or an error in case of failure,
/// such as if an overflow occurs.
-Expected<ExpressionValue> exprAdd(const ExpressionValue &Lhs,
- const ExpressionValue &Rhs, bool &Overflow);
-Expected<ExpressionValue> exprSub(const ExpressionValue &Lhs,
- const ExpressionValue &Rhs, bool &Overflow);
-Expected<ExpressionValue> exprMul(const ExpressionValue &Lhs,
- const ExpressionValue &Rhs, bool &Overflow);
-Expected<ExpressionValue> exprDiv(const ExpressionValue &Lhs,
- const ExpressionValue &Rhs, bool &Overflow);
-Expected<ExpressionValue> exprMax(const ExpressionValue &Lhs,
- const ExpressionValue &Rhs, bool &Overflow);
-Expected<ExpressionValue> exprMin(const ExpressionValue &Lhs,
- const ExpressionValue &Rhs, bool &Overflow);
+Expected<APInt> exprAdd(const APInt &Lhs, const APInt &Rhs, bool &Overflow);
+Expected<APInt> exprSub(const APInt &Lhs, const APInt &Rhs, bool &Overflow);
+Expected<APInt> exprMul(const APInt &Lhs, const APInt &Rhs, bool &Overflow);
+Expected<APInt> exprDiv(const APInt &Lhs, const APInt &Rhs, bool &Overflow);
+Expected<APInt> exprMax(const APInt &Lhs, const APInt &Rhs, bool &Overflow);
+Expected<APInt> exprMin(const APInt &Lhs, const APInt &Rhs, bool &Overflow);
/// Base class representing the AST of a given expression.
class ExpressionAST {
@@ -158,7 +139,7 @@ class ExpressionAST {
/// Evaluates and \returns the value of the expression represented by this
/// AST or an error if evaluation fails.
- virtual Expected<ExpressionValue> eval() const = 0;
+ virtual Expected<APInt> eval() const = 0;
/// \returns either the implicit format of this AST, a diagnostic against
/// \p SM if implicit formats of the AST's components conflict, or NoFormat
@@ -174,14 +155,14 @@ class ExpressionAST {
class ExpressionLiteral : public ExpressionAST {
private:
/// Actual value of the literal.
- ExpressionValue Value;
+ APInt Value;
public:
explicit ExpressionLiteral(StringRef ExpressionStr, APInt Val)
: ExpressionAST(ExpressionStr), Value(Val) {}
/// \returns the literal's value.
- Expected<ExpressionValue> eval() const override { return Value; }
+ Expected<APInt> eval() const override { return Value; }
};
/// Class to represent an undefined variable error, which quotes that
@@ -240,7 +221,7 @@ class NumericVariable {
ExpressionFormat ImplicitFormat;
/// Value of numeric variable, if defined, or std::nullopt otherwise.
- std::optional<ExpressionValue> Value;
+ std::optional<APInt> Value;
/// The input buffer's string from which Value was parsed, or std::nullopt.
/// See comments on getStringValue for a discussion of the std::nullopt case.
@@ -267,7 +248,7 @@ class NumericVariable {
ExpressionFormat getImplicitFormat() const { return ImplicitFormat; }
/// \returns this variable's value.
- std::optional<ExpressionValue> getValue() const { return Value; }
+ std::optional<APInt> 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
@@ -279,7 +260,7 @@ class NumericVariable {
/// 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 std::nullopt.
- void setValue(ExpressionValue NewValue,
+ void setValue(APInt NewValue,
std::optional<StringRef> NewStrValue = std::nullopt) {
Value = NewValue;
StrValue = NewStrValue;
@@ -308,7 +289,7 @@ class NumericVariableUse : public ExpressionAST {
NumericVariableUse(StringRef Name, NumericVariable *Variable)
: ExpressionAST(Name), Variable(Variable) {}
/// \returns the value of the variable referenced by this instance.
- Expected<ExpressionValue> eval() const override;
+ Expected<APInt> eval() const override;
/// \returns implicit format of this numeric variable.
Expected<ExpressionFormat>
@@ -318,9 +299,7 @@ class NumericVariableUse : public ExpressionAST {
};
/// Type of functions evaluating a given binary operation.
-using binop_eval_t = Expected<ExpressionValue> (*)(const ExpressionValue &,
- const ExpressionValue &,
- bool &);
+using binop_eval_t = Expected<APInt> (*)(const APInt &, const APInt &, bool &);
/// Class representing a single binary operation in the AST of an expression.
class BinaryOperation : public ExpressionAST {
@@ -347,7 +326,7 @@ class BinaryOperation : public ExpressionAST {
/// using EvalBinop on the result of recursively evaluating the operands.
/// \returns the expression value or an error if an undefined numeric
/// variable is used in one of the operands.
- Expected<ExpressionValue> eval() const override;
+ Expected<APInt> eval() const override;
/// \returns the implicit format of this AST, if any, a diagnostic against
/// \p SM if the implicit formats of the AST's components conflict, or no
diff --git a/llvm/unittests/FileCheck/FileCheckTest.cpp b/llvm/unittests/FileCheck/FileCheckTest.cpp
index eb7c4dab301f854..15036660b816b31 100644
--- a/llvm/unittests/FileCheck/FileCheckTest.cpp
+++ b/llvm/unittests/FileCheck/FileCheckTest.cpp
@@ -188,8 +188,7 @@ struct ExpressionFormatParameterisedFixture
template <class T> void checkMatchingString(T Val, StringRef ExpectedStr) {
APInt Value(LiteralsBitWidth, Val, std::is_signed_v<T>);
- Expected<std::string> MatchingString =
- Format.getMatchingString(ExpressionValue(Value));
+ Expected<std::string> MatchingString = Format.getMatchingString(Value);
ASSERT_THAT_EXPECTED(MatchingString, Succeeded())
<< "No matching string for " << Val;
EXPECT_EQ(*MatchingString, ExpectedStr);
@@ -197,34 +196,33 @@ struct ExpressionFormatParameterisedFixture
template <class T> void checkMatchingStringFailure(T Val) {
APInt Value(LiteralsBitWidth, Val, std::is_signed_v<T>);
- Expected<std::string> MatchingString =
- Format.getMatchingString(ExpressionValue(Value));
- // Error message tested in ExpressionValue unit tests.
+ Expected<std::string> MatchingString = Format.getMatchingString(Value);
+ // Error message tested in ExpressionFormat unit tests.
EXPECT_THAT_EXPECTED(MatchingString, Failed());
}
- Expected<ExpressionValue> getValueFromStringReprFailure(StringRef Str) {
+ Expected<APInt> getValueFromStringReprFailure(StringRef Str) {
StringRef BufferizedStr = bufferize(SM, Str);
return Format.valueFromStringRepr(BufferizedStr, SM);
}
template <class T>
void checkValueFromStringRepr(StringRef Str, T ExpectedVal) {
- Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
+ Expected<APInt> ResultValue = getValueFromStringReprFailure(Str);
ASSERT_THAT_EXPECTED(ResultValue, Succeeded())
<< "Failed to get value from " << Str;
- APInt ResValue = ResultValue->getAPIntValue();
- ASSERT_EQ(ResValue.isNegative(), ExpectedVal < 0)
+ ASSERT_EQ(ResultValue->isNegative(), ExpectedVal < 0)
<< "Value for " << Str << " is not " << ExpectedVal;
- if (ResValue.isNegative())
- EXPECT_EQ(ResValue.getSExtValue(), static_cast<int64_t>(ExpectedVal));
+ if (ResultValue->isNegative())
+ EXPECT_EQ(ResultValue->getSExtValue(), static_cast<int64_t>(ExpectedVal));
else
- EXPECT_EQ(ResValue.getZExtValue(), static_cast<uint64_t>(ExpectedVal));
+ EXPECT_EQ(ResultValue->getZExtValue(),
+ static_cast<uint64_t>(ExpectedVal));
}
void checkValueFromStringReprFailure(
StringRef Str, StringRef ErrorStr = "unable to represent numeric value") {
- Expected<ExpressionValue> ResultValue = getValueFromStringReprFailure(Str);
+ Expected<APInt> ResultValue = getValueFromStringReprFailure(Str);
expectDiagnosticError(ErrorStr, ResultValue.takeError());
}
};
@@ -363,7 +361,7 @@ TEST_F(FileCheckTest, NoFormatProperties) {
NoFormat.getWildcardRegex().takeError());
expectError<StringError>(
"trying to match value with invalid format",
- NoFormat.getMatchingString(ExpressionValue(APInt(64, 18u))).takeError());
+ NoFormat.getMatchingString(APInt(64, 18u)).takeError());
EXPECT_FALSE(bool(NoFormat));
}
@@ -397,12 +395,9 @@ TEST_F(FileCheckTest, FormatKindEqualityOperators) {
static void expectOperationValueResult(binop_eval_t Operation, APInt LeftValue,
APInt RightValue, APInt ExpectedValue) {
bool Overflow;
- ExpressionValue LeftVal(LeftValue);
- ExpressionValue RightVal(RightValue);
- Expected<ExpressionValue> OperationResult =
- Operation(LeftVal, RightVal, Overflow);
+ Expected<APInt> OperationResult = Operation(LeftValue, RightValue, Overflow);
ASSERT_THAT_EXPECTED(OperationResult, Succeeded());
- EXPECT_EQ(OperationResult->getAPIntValue(), ExpectedValue);
+ EXPECT_EQ(*OperationResult, ExpectedValue);
}
template <class T1, class T2, class TR>
@@ -421,10 +416,8 @@ template <class T1, class T2>
static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
T2 RightValue) {
bool Overflow;
- ExpressionValue LeftVal(
- APInt(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>));
- ExpressionValue RightVal(
- APInt(LiteralsBitWidth, RightValue, std::is_signed_v<T2>));
+ APInt LeftVal(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>);
+ APInt RightVal(LiteralsBitWidth, RightValue, std::is_signed_v<T2>);
expectError<OverflowError>(
"overflow error", Operation(LeftVal, RightVal, Overflow).takeError());
}
@@ -565,9 +558,9 @@ TEST_F(FileCheckTest, Literal) {
// Eval returns the literal's value.
ExpressionLiteral Ten(bufferize(SM, "10"), APInt(64, 10u));
- Expected<ExpressionValue> Value = Ten.eval();
+ Expected<APInt> Value = Ten.eval();
ASSERT_THAT_EXPECTED(Value, Succeeded());
- EXPECT_EQ(10, Value->getAPIntValue().getSExtValue());
+ EXPECT_EQ(10, Value->getSExtValue());
Expected<ExpressionFormat> ImplicitFormat = Ten.getImplicitFormat(SM);
ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::NoFormat);
@@ -577,14 +570,14 @@ TEST_F(FileCheckTest, Literal) {
APInt(64, MinInt64, /*IsSigned=*/true));
Value = Min.eval();
ASSERT_TRUE(bool(Value));
- EXPECT_EQ(MinInt64, Value->getAPIntValue().getSExtValue());
+ EXPECT_EQ(MinInt64, Value->getSExtValue());
// Max value can be correctly represented.
ExpressionLiteral Max(bufferize(SM, std::to_string(MaxUint64)),
APInt(64, MaxUint64));
Value = Max.eval();
ASSERT_THAT_EXPECTED(Value, Succeeded());
- EXPECT_EQ(MaxUint64, Value->getAPIntValue().getZExtValue());
+ EXPECT_EQ(MaxUint64, Value->getZExtValue());
}
TEST_F(FileCheckTest, Expression) {
@@ -626,33 +619,33 @@ TEST_F(FileCheckTest, NumericVariable) {
ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
EXPECT_FALSE(FooVar.getValue());
- Expected<ExpressionValue> EvalResult = FooVarUse.eval();
+ Expected<APInt> EvalResult = FooVarUse.eval();
expectUndefErrors({"FOO"}, EvalResult.takeError());
// Defined variable without string: only getValue and eval return value set.
- FooVar.setValue(ExpressionValue(APInt(64, 42u)));
- std::optional<ExpressionValue> Value = FooVar.getValue();
+ FooVar.setValue(APInt(64, 42u));
+ std::optional<APInt> Value = FooVar.getValue();
ASSERT_TRUE(Value);
- EXPECT_EQ(42, Value->getAPIntValue().getSExtValue());
+ EXPECT_EQ(42, Value->getSExtValue());
EXPECT_FALSE(FooVar.getStringValue());
EvalResult = FooVarUse.eval();
ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
- EXPECT_EQ(42, EvalResult->getAPIntValue().getSExtValue());
+ EXPECT_EQ(42, EvalResult->getSExtValue());
// Defined variable with string: getValue, eval, and getStringValue return
// value set.
StringRef StringValue = "925";
- FooVar.setValue(ExpressionValue(APInt(64, 925u)), StringValue);
+ FooVar.setValue(APInt(64, 925u), StringValue);
Value = FooVar.getValue();
ASSERT_TRUE(Value);
- EXPECT_EQ(925, Value->getAPIntValue().getSExtValue());
+ EXPECT_EQ(925, Value->getSExtValue());
// getStringValue should return the same memory not just the same characters.
EXPECT_EQ(StringValue.begin(), FooVar.getStringValue()->begin());
EXPECT_EQ(StringValue.end(), FooVar.getStringValue()->end());
EvalResult = FooVarUse.eval();
ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
- EXPECT_EQ(925, EvalResult->getAPIntValue().getSExtValue());
- EXPECT_EQ(925, EvalResult->getAPIntValue().getSExtValue());
+ EXPECT_EQ(925, EvalResult->getSExtValue());
+ EXPECT_EQ(925, EvalResult->getSExtValue());
// Clearing variable: getValue and eval fail. Error returned by eval holds
// the name of the cleared variable.
@@ -670,13 +663,13 @@ TEST_F(FileCheckTest, Binop) {
StringRef FooStr = ExprStr.take_front(3);
NumericVariable FooVar(FooStr,
ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
- FooVar.setValue(ExpressionValue(APInt(64, 42u)));
+ FooVar.setValue(APInt(64, 42u));
std::unique_ptr<NumericVariableUse> FooVarUse =
std::make_unique<NumericVariableUse>(FooStr, &FooVar);
StringRef BarStr = ExprStr.take_back(3);
NumericVariable BarVar(BarStr,
ExpressionFormat(ExpressionFormat::Kind::Unsigned), 2);
- BarVar.setValue(ExpressionValue(APInt(64, 18u)));
+ BarVar.setValue(APInt(64, 18u));
std::unique_ptr<NumericVariableUse> BarVarUse =
std::make_unique<NumericVariableUse>(BarStr, &BarVar);
BinaryOperation Binop(ExprStr, exprAdd, std::move(FooVarUse),
@@ -684,29 +677,28 @@ TEST_F(FileCheckTest, Binop) {
// Defined variables with same bitwidth and no overflow: eval returns right
// value; implicit formas is as expected.
- Expected<ExpressionValue> Value = Binop.eval();
+ Expected<APInt> Value = Binop.eval();
ASSERT_THAT_EXPECTED(Value, Succeeded());
- EXPECT_EQ(60, Value->getAPIntValue().getSExtValue());
+ EXPECT_EQ(60, Value->getSExtValue());
Expected<ExpressionFormat> ImplicitFormat = Binop.getImplicitFormat(SM);
ASSERT_THAT_EXPECTED(ImplicitFormat, Succeeded());
EXPECT_EQ(*ImplicitFormat, ExpressionFormat::Kind::Unsigned);
// Defined variables with
diff erent bitwidth and no overflow: eval succeeds
// and return the right value.
- BarVar.setValue(ExpressionValue(APInt(32, 18u)));
+ BarVar.setValue(APInt(32, 18u));
Value = Binop.eval();
ASSERT_THAT_EXPECTED(Value, Succeeded());
- EXPECT_EQ(60, Value->getAPIntValue().getSExtValue());
+ EXPECT_EQ(60, Value->getSExtValue());
// Defined variables with same bitwidth and wider result (i.e. overflow):
// eval succeeds and return the right value in a wider APInt.
- BarVar.setValue(ExpressionValue(APInt(64, AbsoluteMaxInt64)));
+ BarVar.setValue(APInt(64, AbsoluteMaxInt64));
Value = Binop.eval();
ASSERT_THAT_EXPECTED(Value, Succeeded());
- EXPECT_EQ(128u, Value->getAPIntValue().getBitWidth());
- EXPECT_EQ(APInt(128, AbsoluteMaxInt64 +
- FooVar.getValue()->getAPIntValue().getZExtValue()),
- Value->getAPIntValue());
+ EXPECT_EQ(128u, Value->getBitWidth());
+ EXPECT_EQ(APInt(128, AbsoluteMaxInt64 + FooVar.getValue()->getZExtValue()),
+ *Value);
// 1 undefined variable: eval fails, error contains name of undefined
// variable.
@@ -1463,7 +1455,7 @@ TEST_F(FileCheckTest, Substitution) {
// substituted for the variable's value.
NumericVariable NVar("N", ExpressionFormat(ExpressionFormat::Kind::Unsigned),
1);
- NVar.setValue(ExpressionValue(APInt(64, 10u)));
+ NVar.setValue(APInt(64, 10u));
auto NVarUse = std::make_unique<NumericVariableUse>("N", &NVar);
auto ExpressionN = std::make_unique<Expression>(
std::move(NVarUse), ExpressionFormat(ExpressionFormat::Kind::HexUpper));
@@ -1573,24 +1565,23 @@ TEST_F(FileCheckTest, FileCheckContext) {
Expected<StringRef> EmptyVar = Cxt.getPatternVarValue(EmptyVarStr);
Expected<StringRef> UnknownVar = Cxt.getPatternVarValue(UnknownVarStr);
ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
- Expected<ExpressionValue> ExpressionVal =
- (*ExpressionPointer)->getAST()->eval();
+ Expected<APInt> ExpressionVal = (*ExpressionPointer)->getAST()->eval();
ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
- EXPECT_EQ(ExpressionVal->getAPIntValue().getSExtValue(), 18);
+ EXPECT_EQ(ExpressionVal->getSExtValue(), 18);
ExpressionPointer = P.parseNumericSubstitutionBlock(
LocalNumVar2Ref, DefinedNumericVariable,
/*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
ExpressionVal = (*ExpressionPointer)->getAST()->eval();
ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
- EXPECT_EQ(ExpressionVal->getAPIntValue().getSExtValue(), 20);
+ EXPECT_EQ(ExpressionVal->getSExtValue(), 20);
ExpressionPointer = P.parseNumericSubstitutionBlock(
LocalNumVar3Ref, DefinedNumericVariable,
/*IsLegacyLineExpr=*/false, LineNumber, &Cxt, SM);
ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
ExpressionVal = (*ExpressionPointer)->getAST()->eval();
ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
- EXPECT_EQ(ExpressionVal->getAPIntValue().getSExtValue(), 12);
+ EXPECT_EQ(ExpressionVal->getSExtValue(), 12);
ASSERT_THAT_EXPECTED(EmptyVar, Succeeded());
EXPECT_EQ(*EmptyVar, "");
expectUndefErrors({std::string(UnknownVarStr)}, UnknownVar.takeError());
@@ -1640,7 +1631,7 @@ TEST_F(FileCheckTest, FileCheckContext) {
ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
ExpressionVal = (*ExpressionPointer)->getAST()->eval();
ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
- EXPECT_EQ(ExpressionVal->getAPIntValue().getSExtValue(), 36);
+ EXPECT_EQ(ExpressionVal->getSExtValue(), 36);
// Clear local variables and check global variables remain defined.
Cxt.clearLocalVars();
@@ -1652,7 +1643,7 @@ TEST_F(FileCheckTest, FileCheckContext) {
ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
ExpressionVal = (*ExpressionPointer)->getAST()->eval();
ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
- EXPECT_EQ(ExpressionVal->getAPIntValue().getSExtValue(), 36);
+ EXPECT_EQ(ExpressionVal->getSExtValue(), 36);
}
TEST_F(FileCheckTest, CapturedVarDiags) {
More information about the llvm-commits
mailing list