[FileCheck, 4/4] NFC: Stop using ExpressionValue

[thopre]

Summary

Use APInt directly instead.

Depends On D150880

[arichardson]

llvm/lib/FileCheck/FileCheck.cpp

82

Could also rename the argument here instead of updating all users?

[thopre]

Address review comments

llvm/lib/FileCheck/FileCheck.cpp

82

Sure, I was trying to keep naming consistent.

llvm/lib/FileCheck/FileCheck.cpp

case Kind::HexLower:
     return (Twine(AlternateFormPrefix) + Twine("[0-9a-f]+")).str();
   default:
     return createStringError(std::errc::invalid_argument,
                              "trying to match value with invalid format");
   }
 }
 
 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>();
 
   unsigned Radix;
   bool UpperCase = false;
   SmallString<8> AbsoluteValueStr;
   StringRef SignPrefix = IntValue.isNegative() ? "-" : "";
   switch (Value) {
   case Kind::Unsigned:
static APInt toSigned(APInt AbsVal, bool Negative) {
   if (AbsVal.isSignBitSet())
     AbsVal = AbsVal.zext(nextAPIntBitWidth(AbsVal.getBitWidth()));
   APInt Result = AbsVal;
   if (Negative)
     Result.negate();
   return Result;
 }
 
-Expected<ExpressionValue>
+Expected<APInt>
 ExpressionFormat::valueFromStringRepr(StringRef StrVal,
                                       const SourceMgr &SM) const {
   bool ValueIsSigned = Value == Kind::Signed;
   // Both the FileCheck utility and library only call this method with a valid
   // value in StrVal. This is guaranteed by the regex returned by
   // getWildcardRegex() above. Only underflow and overflow errors can thus
   // occur. However new uses of this method could be added in the future so
   // the error message does not make assumptions about StrVal.
   bool Negative = StrVal.consume_front("-");
   bool Hex = Value == Kind::HexUpper || Value == Kind::HexLower;
   bool MissingFormPrefix =
       !ValueIsSigned && AlternateForm && !StrVal.consume_front("0x");
   (void)MissingFormPrefix;
   assert(!MissingFormPrefix && "missing alternate form prefix");
   APInt ResultValue;
   bool ParseFailure = StrVal.getAsInteger(Hex ? 16 : 10, ResultValue);
   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.
   if (!MaybeLeftOp || !MaybeRightOp) {
     Error Err = Error::success();
     if (!MaybeLeftOp)
       Err = joinErrors(std::move(Err), MaybeLeftOp.takeError());
     if (!MaybeRightOp)
       Err = joinErrors(std::move(Err), MaybeRightOp.takeError());
     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();
   unsigned RightBitWidth = RightOp.getBitWidth();
   unsigned NewBitWidth = std::max(LeftBitWidth, RightBitWidth);
   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();
 
     if (!Overflow)
       return MaybeResult;
 
     NewBitWidth = nextAPIntBitWidth(NewBitWidth);
     LeftOp = LeftOp.sext(NewBitWidth);
BinaryOperation::getImplicitFormat(const SourceMgr &SM) const {
 
   return *LeftFormat != ExpressionFormat::Kind::NoFormat ? *LeftFormat
                                                          : *RightFormat;
 }
 
 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();
   return Format.getMatchingString(*EvaluatedValue);
 }
 
 Expected<std::string> StringSubstitution::getResult() const {
   // Look up the value and escape it so that we can put it into the regex.
Pattern::MatchResult Pattern::match(StringRef Buffer,
   // If there are substitutions, we need to create a temporary string with the
   // actual value.
   StringRef RegExToMatch = RegExStr;
   std::string TmpStr;
   if (!Substitutions.empty()) {
     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
     // now known. Use of string variables defined on the same line are handled
     // by back-references.
     Error Errs = Error::success();
     for (const auto &Substitution : Substitutions) {
       // Substitute and check for failure (e.g. use of undefined variable).
const NumericVariableMatch &NumericVariableMatch =
         NumericVariableDef.getValue();
     unsigned CaptureParenGroup = NumericVariableMatch.CaptureParenGroup;
     assert(CaptureParenGroup < MatchInfo.size() && "Internal paren error");
     NumericVariable *DefinedNumericVariable =
         NumericVariableMatch.DefinedNumericVariable;
 
     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);
   }
 
   return MatchResult(TheMatch, Error::success());
 }
 
if (CmdlineDef[0] == '#') {
         Errs = joinErrors(std::move(Errs), ExpressionResult.takeError());
         continue;
       }
       std::unique_ptr<Expression> Expression = std::move(*ExpressionResult);
       // Now evaluate the expression whose value this variable should be set
       // 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;
       }
 
       assert(DefinedNumericVariable && "No variable defined");
       (*DefinedNumericVariable)->setValue(*Value);
 

llvm/lib/FileCheck/FileCheckImpl.h

 #include <vector>
 
 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.
 struct ExpressionFormat {
   enum class Kind {
     /// Denote absence of format. Used for implicit format of literals and
     /// empty expressions.
     NoFormat,
public:
   /// \returns a wildcard regular expression string that matches any value in
   /// the format represented by this instance and no other value, or an error
   /// if the format is NoFormat.
   Expected<std::string> getWildcardRegex() const;
 
   /// \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,
 };
 
 /// Class to represent an overflow error that might result when manipulating a
 /// value.
 class OverflowError : public ErrorInfo<OverflowError> {
 public:
   static char ID;
 
   std::error_code convertToErrorCode() const override {
     return std::make_error_code(std::errc::value_too_large);
   }
 
   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 {
 private:
   StringRef ExpressionStr;
 
 public:
   ExpressionAST(StringRef ExpressionStr) : ExpressionStr(ExpressionStr) {}
 
   virtual ~ExpressionAST() = default;
 
   StringRef getExpressionStr() const { return ExpressionStr; }
 
   /// 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
   /// if the AST has no implicit format (e.g. AST is made up of a single
   /// literal).
   virtual Expected<ExpressionFormat>
   getImplicitFormat(const SourceMgr &SM) const {
     return ExpressionFormat();
   }
 };
 
 /// Class representing an unsigned literal in the AST of an expression.
 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
 /// variable's name when printed.
 class UndefVarError : public ErrorInfo<UndefVarError> {
 private:
   StringRef VarName;
 
private:
   /// Name of the numeric variable.
   StringRef Name;
 
   /// Format to use for expressions using this variable without an explicit
   /// format.
   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.
   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.
public:
 
   /// \returns name of this numeric variable.
   StringRef getName() const { return Name; }
 
   /// \returns implicit format of this numeric variable.
   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
   /// 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.
   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 std::nullopt.
-  void setValue(ExpressionValue NewValue,
+  void setValue(APInt NewValue,
                 std::optional<StringRef> NewStrValue = std::nullopt) {
     Value = NewValue;
     StrValue = NewStrValue;
   }
 
   /// Clears value of this numeric variable, regardless of whether it is
   /// currently defined or not.
   void clearValue() {

 private:
   /// Pointer to the class instance for the variable this use is about.
   NumericVariable *Variable;
 
 public:
   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>
   getImplicitFormat(const SourceMgr &SM) const override {
     return Variable->getImplicitFormat();
   }
 };
 
 /// 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 {
 private:
   /// Left operand.
   std::unique_ptr<ExpressionAST> LeftOperand;
 
   /// Right operand.
BinaryOperation(StringRef ExpressionStr, binop_eval_t EvalBinop,
     LeftOperand = std::move(LeftOp);
     RightOperand = std::move(RightOp);
   }
 
   /// Evaluates the value of the binary operation represented by this AST,
   /// 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
   /// format if the AST has no implicit format (e.g. AST is made of a single
   /// literal).
   Expected<ExpressionFormat>
   getImplicitFormat(const SourceMgr &SM) const override;
 };

llvm/unittests/FileCheck/FileCheckTest.cpp

std::string padWithLeadingZeros(StringRef NumStr) const {
     }
     PaddedStr.append(Precision - NumStr.size(), '0');
     PaddedStr.append(NumStr.str());
     return PaddedStr;
   }
 
   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);
   }
 
   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());
   }
 };
 
 TEST_P(ExpressionFormatParameterisedFixture, FormatGetWildcardRegex) {
   // Wildcard regex is valid.
   Expected<std::string> WildcardPattern = Format.getWildcardRegex();
   ASSERT_THAT_EXPECTED(WildcardPattern, Succeeded());
::testing::Values(
         std::make_tuple(ExpressionFormat::Kind::Signed, 20, false)));
 
 TEST_F(FileCheckTest, NoFormatProperties) {
   ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
   expectError<StringError>("trying to match value with invalid format",
                            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));
 }
 
 TEST_F(FileCheckTest, FormatEqualityOperators) {
   ExpressionFormat UnsignedFormat(ExpressionFormat::Kind::Unsigned);
   ExpressionFormat UnsignedFormat2(ExpressionFormat::Kind::Unsigned);
   EXPECT_TRUE(UnsignedFormat == UnsignedFormat2);
   EXPECT_FALSE(UnsignedFormat != UnsignedFormat2);
TEST_F(FileCheckTest, FormatKindEqualityOperators) {
   ExpressionFormat NoFormat(ExpressionFormat::Kind::NoFormat);
   EXPECT_TRUE(NoFormat == ExpressionFormat::Kind::NoFormat);
   EXPECT_FALSE(NoFormat != ExpressionFormat::Kind::NoFormat);
 }
 
 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>
 static void expectOperationValueResult(binop_eval_t Operation, T1 LeftValue,
                                        T2 RightValue, TR ResultValue) {
   APInt LeftVal(LiteralsBitWidth, LeftValue, std::is_signed_v<T1>);
   APInt RightVal(LiteralsBitWidth, RightValue, std::is_signed_v<T2>);
   APInt ResultVal =
       std::is_integral_v<TR>
           ? APInt(LiteralsBitWidth, ResultValue, std::is_signed_v<TR>)
           : APInt(LiteralsBitWidth, ResultValue, /*Radix=*/10);
   expectOperationValueResult(Operation, LeftVal, RightVal, ResultVal);
 }
 
 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());
 }
 
 TEST_F(FileCheckTest, ExpressionValueAddition) {
   // Test both negative values.
   expectOperationValueResult(exprAdd, -10, -10, -20);
 
expectOperationValueResult(exprDiv, AbsoluteMaxInt64 + 2, -1,
                              "-9223372036854775809");
 }
 
 TEST_F(FileCheckTest, Literal) {
   SourceMgr SM;
 
   // 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);
 
   // Min value can be correctly represented.
   ExpressionLiteral Min(bufferize(SM, std::to_string(MinInt64)),
                         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) {
   SourceMgr SM;
 
   std::unique_ptr<ExpressionLiteral> Ten =
       std::make_unique<ExpressionLiteral>(bufferize(SM, "10"), APInt(64, 10u));
   ExpressionLiteral *TenPtr = Ten.get();
NumericVariable FooVar("FOO",
                          ExpressionFormat(ExpressionFormat::Kind::Unsigned), 1);
   EXPECT_EQ("FOO", FooVar.getName());
   EXPECT_EQ(FooVar.getImplicitFormat(), ExpressionFormat::Kind::Unsigned);
   NumericVariableUse FooVarUse("FOO", &FooVar);
   Expected<ExpressionFormat> ImplicitFormat = FooVarUse.getImplicitFormat(SM);
   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.
   FooVar.clearValue();
   EXPECT_FALSE(FooVar.getValue());
   EXPECT_FALSE(FooVar.getStringValue());
   EvalResult = FooVarUse.eval();
   expectUndefErrors({"FOO"}, EvalResult.takeError());
 }
 
 TEST_F(FileCheckTest, Binop) {
   SourceMgr SM;
 
   StringRef ExprStr = bufferize(SM, "FOO+BAR");
   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),
                         std::move(BarVarUse));
 
   // 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 different 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.
   FooVar.clearValue();
   Value = Binop.eval();
   expectUndefErrors({"FOO"}, Value.takeError());
 
   // 2 undefined variables: eval fails, error contains names of all undefined
TEST_F(FileCheckTest, Substitution) {
   StringSubstitution StringSubstitution(&Context, "VAR404", 42);
   Expected<std::string> SubstValue = StringSubstitution.getResult();
   expectUndefErrors({"VAR404"}, SubstValue.takeError());
 
   // Numeric substitution blocks constituted of defined numeric variables are
   // 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));
   NumericSubstitution SubstitutionN(&Context, "N", std::move(ExpressionN),
                                     /*InsertIdx=*/30);
   SubstValue = SubstitutionN.getResult();
   ASSERT_THAT_EXPECTED(SubstValue, Succeeded());
   EXPECT_EQ("A", *SubstValue);
Expected<std::unique_ptr<Expression>> ExpressionPointer =
       P.parseNumericSubstitutionBlock(LocalNumVar1Ref, DefinedNumericVariable,
                                       /*IsLegacyLineExpr=*/false, LineNumber,
                                       &Cxt, SM);
   ASSERT_THAT_EXPECTED(LocalVar, Succeeded());
   EXPECT_EQ(*LocalVar, "FOO");
   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());
 
   // Clear local variables and check they become absent.
   Cxt.clearLocalVars();
   LocalVar = Cxt.getPatternVarValue(LocalVarStr);
   expectUndefErrors({std::string(LocalVarStr)}, LocalVar.takeError());
#endif
   EXPECT_EQ(*GlobalVar, "BAR");
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, 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(), 36);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 36);
 
   // Clear local variables and check global variables remain defined.
   Cxt.clearLocalVars();
   EXPECT_THAT_EXPECTED(Cxt.getPatternVarValue(GlobalVarStr), Succeeded());
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, 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(), 36);
+  EXPECT_EQ(ExpressionVal->getSExtValue(), 36);
 }
 
 TEST_F(FileCheckTest, CapturedVarDiags) {
   PatternTester Tester;
   ASSERT_FALSE(Tester.parsePattern("[[STRVAR:[a-z]+]] [[#NUMVAR:@LINE]]"));
   EXPECT_THAT_EXPECTED(Tester.match("foobar 2"), Succeeded());
   std::vector<FileCheckDiag> Diags;
   Tester.printVariableDefs(FileCheckDiag::MatchFoundAndExpected, Diags);