[ASTMatchers] Add support for floatLiterals

[Lekensteyn]

Summary

Needed to support something like "floatLiteral(equals(1.0))". The
parser for floating point numbers is kept simple, so instead of ".1" you
have to use "0.1".

[aaron.ballman]

include/clang/ASTMatchers/Dynamic/Parser.h

25

It'd be good to list the actual grammar rather than a few examples.

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

This may or may not be a good idea, but do we want to put the values into an APFloat rather than a double? My concern with double is that (0) it may be subtly different if the user wants a 16- or 32-bit float explicitly, (1) it won't be able to represent long double values, or quad double.

I'm thinking this value could be passed directly from the C++ API as an APFloat, float, or double, or provided using a StringRef for the dynamic API.

lib/ASTMatchers/Dynamic/Parser.cpp

180

This function should be renamed and the comment updated.

[Lekensteyn]

By the way, I think that long double is less common than long unsigned literals, so changing unsigned to uint64_t might be something more important?

include/clang/ASTMatchers/Dynamic/Parser.h

25

I am concerned that listing a very precise grammar actually makes this less readable (see also the StringLiteral example).

If a grammar is used instead, how about this:

<Double> := [0-9]+.[0-9]* | [0-9]+.[0-9]*[eE][-+]?[0-9]+

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

(32-bit) double values are a superset of (16-bit) float values, that should be OK.
Long doubles are possible in the AST (e.g. for 0.1L), but neither C11 nor C++14 seem to define a quad double literal type (so that should be of a lesser concern).

Reasons why I chose for double instead of APFloat:

• strtod is readily available and does not abort the program. By contrast, APFloat(StringRef) trips on assertions if the input is invalid.
• I was not sure if the APFloat class can be used in an union.

lib/ASTMatchers/Dynamic/Parser.cpp

180

How does "consumeNumberLiteral" sound?

[aaron.ballman]

In D33135#754278, @Lekensteyn wrote:

By the way, I think that long double is less common than long unsigned literals, so changing unsigned to uint64_t might be something more important?

I agree that it's likely a more common use case. There doesn't appear to be a suffix for __int128 (we talked about adding i128 once upon a time, but I don't believe it got in), so you may be okay using a uint64_t there rather than an APInt.

include/clang/ASTMatchers/Dynamic/Parser.h

25

That's reasonable enough.

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

The downside to using strtod() is that invalid input is silently accepted. However, assertions on invalid input is certainly not good either. It might be worth modifying APFloat::convertFromString() to accept invalid input and return an error.

I think instead of an APFloat, maybe using an APValue for both the Unsigned and Double fields might work. At the very least, it should give you implementation ideas.

There is a quad double literal suffix: q. It's only supported on some architectures, however. There are also imaginary numbers (i) and half (h).

lib/ASTMatchers/Dynamic/Parser.cpp

180

Sounds good to me.

209

You're failing to check errno here to ensure the value is actually valid.

[Lekensteyn]

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

The strtod conversion was based on parseDouble in lib/Support/CommandLine.cpp, so any conversion issues also exist there.

Same question, can APFloat/APValue be used in a union?

float (or quad-double suffixes) are explicitly not supported now in this matcher, maybe they can be added later but for now I decided to keep the grammar simple (that is, do not express double/float data types via the literal).

lib/ASTMatchers/Dynamic/Parser.cpp

209

will check this later, see also the previous comment

[aaron.ballman]

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

The strtod conversion was based on parseDouble in lib/Support/CommandLine.cpp, so any conversion issues also exist there.

Good to know.

Same question, can APFloat/APValue be used in a union?

I believe so, but I've not tried it myself. Also, as I mentioned, APValue demonstrates another implementation strategy in case you cannot use a union directly.

float (or quad-double suffixes) are explicitly not supported now in this matcher, maybe they can be added later but for now I decided to keep the grammar simple (that is, do not express double/float data types via the literal).

That's reasonable for an initial implementation.

[Lekensteyn]

diff from previous version:

diff --git a/include/clang/ASTMatchers/Dynamic/Parser.h b/include/clang/ASTMatchers/Dynamic/Parser.h
index 0d0c2ba540..5ec4a9abf4 100644
--- a/include/clang/ASTMatchers/Dynamic/Parser.h
+++ b/include/clang/ASTMatchers/Dynamic/Parser.h
@@ -22,7 +22,7 @@
 /// <Literal>           := <StringLiteral> | <Boolean> | <Double> | <Unsigned>
 /// <StringLiteral>     := "quoted string"
 /// <Boolean>           := true | false
-/// <Double>            := 1.0 | 2e-3 | 3.45e67
+/// <Double>            := [0-9]+.[0-9]* | [0-9]+.[0-9]*[eE][-+]?[0-9]+
 /// <Unsigned>          := [0-9]+
 /// <NamedValue>        := <Identifier>
 /// <MatcherExpression> := <Identifier>(<ArgumentList>) |
diff --git a/lib/ASTMatchers/Dynamic/Parser.cpp b/lib/ASTMatchers/Dynamic/Parser.cpp
index 669e5ca44f..ff5c5fb657 100644
--- a/lib/ASTMatchers/Dynamic/Parser.cpp
+++ b/lib/ASTMatchers/Dynamic/Parser.cpp
@@ -130,8 +130,8 @@ private:
 
     case '0': case '1': case '2': case '3': case '4':
     case '5': case '6': case '7': case '8': case '9':
-      // Parse an unsigned literal.
-      consumeUnsignedLiteral(&Result);
+      // Parse an unsigned and float literal.
+      consumeNumberLiteral(&Result);
       break;
 
     default:
@@ -176,8 +176,8 @@ private:
     return Result;
   }
 
-  /// \brief Consume an unsigned literal.
-  void consumeUnsignedLiteral(TokenInfo *Result) {
+  /// \brief Consume an unsigned and float literal.
+  void consumeNumberLiteral(TokenInfo *Result) {
     bool isFloatingLiteral = false;
     unsigned Length = 1;
     if (Code.size() > 1) {
@@ -205,8 +205,9 @@ private:
 
     if (isFloatingLiteral) {
       char *end;
+      errno = 0;
       double doubleValue = strtod(Result->Text.str().c_str(), &end);
-      if (*end == 0) {
+      if (*end == 0 && errno == 0) {
         Result->Kind = TokenInfo::TK_Literal;
         Result->Value = doubleValue;
         return;

[Lekensteyn]

Rebased patches on latest clang master (trunk), there were no changes in ASTMatchers.
boolean literal patch was unchanged, this floating literal patch was updated to address comments.

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

I think I'll keep it like this for now and defer eventual conversion to APValue for a future patch that also makes uint64_t possible. Is that OK?

[aaron.ballman]

LGTM!

include/clang/ASTMatchers/Dynamic/VariantValue.h

335

Okay, that seems reasonable to me.

include/clang/ASTMatchers/Dynamic/Diagnostics.h

enum ErrorType {
     ET_ParserNoOpenParen = 101,
     ET_ParserNoCloseParen = 102,
     ET_ParserNoComma = 103,
     ET_ParserNoCode = 104,
     ET_ParserNotAMatcher = 105,
     ET_ParserInvalidToken = 106,
     ET_ParserMalformedBindExpr = 107,
     ET_ParserTrailingCode = 108,
-    ET_ParserUnsignedError = 109,
+    ET_ParserNumberError = 109,
     ET_ParserOverloadedType = 110
   };
 
   /// \brief Helper stream class.
   class ArgStream {
   public:
     ArgStream(std::vector<std::string> *Out) : Out(Out) {}
     template <class T> ArgStream &operator<<(const T &Arg) {

include/clang/ASTMatchers/Dynamic/Parser.h

 ///   MatcherName(Arg0, Arg1, ..., ArgN)
 /// as well as simple types like strings.
 /// The parser does not know how to process the matchers. It delegates this task
 /// to a Sema object received as an argument.
 ///
 /// \code
 /// Grammar for the expressions supported:
 /// <Expression>        := <Literal> | <NamedValue> | <MatcherExpression>
-/// <Literal>           := <StringLiteral> | <Boolean> | <Unsigned>
+/// <Literal>           := <StringLiteral> | <Boolean> | <Double> | <Unsigned>
 /// <StringLiteral>     := "quoted string"
 /// <Boolean>           := true | false
+/// <Double>            := 1.0 | 2e-3 | 3.45e67
 /// <Unsigned>          := [0-9]+
 /// <NamedValue>        := <Identifier>
 /// <MatcherExpression> := <Identifier>(<ArgumentList>) |
 ///                        <Identifier>(<ArgumentList>).bind(<StringLiteral>)
 /// <Identifier>        := [a-zA-Z]+
 /// <ArgumentList>      := <Expression> | <Expression>,<ArgumentList>
 /// \endcode
 ///

include/clang/ASTMatchers/Dynamic/VariantValue.h

 /// \brief Kind identifier.
 ///
 /// It supports all types that VariantValue can contain.
 class ArgKind {
  public:
   enum Kind {
     AK_Matcher,
     AK_Boolean,
+    AK_Double,
     AK_Unsigned,
     AK_String
   };
   /// \brief Constructor for non-matcher types.
   ArgKind(Kind K) : K(K) { assert(K != AK_Matcher); }
 
   /// \brief Constructor for matcher types.
   ArgKind(ast_type_traits::ASTNodeKind MatcherKind)

 /// Basically, a tagged union with value type semantics.
 /// It is used by the registry as the return value and argument type for the
 /// matcher factory methods.
 /// It can be constructed from any of the supported types. It supports
 /// copy/assignment.
 ///
 /// Supported types:
 ///  - \c bool
+//   - \c double
 ///  - \c unsigned
 ///  - \c llvm::StringRef
 ///  - \c VariantMatcher (\c DynTypedMatcher / \c Matcher<T>)
 class VariantValue {
 public:
   VariantValue() : Type(VT_Nothing) {}
 
   VariantValue(const VariantValue &Other);
   ~VariantValue();
   VariantValue &operator=(const VariantValue &Other);
 
   /// \brief Specific constructors for each supported type.
   VariantValue(bool Boolean);
+  VariantValue(double Double);
   VariantValue(unsigned Unsigned);
   VariantValue(StringRef String);
   VariantValue(const VariantMatcher &Matchers);
 
   /// \brief Constructs an \c unsigned value (disambiguation from bool).
   VariantValue(int Signed) : VariantValue(static_cast<unsigned>(Signed)) {}
 
   /// \brief Returns true iff this is not an empty value.
   explicit operator bool() const { return hasValue(); }
   bool hasValue() const { return Type != VT_Nothing; }
 
   /// \brief Boolean value functions.
   bool isBoolean() const;
   bool getBoolean() const;
   void setBoolean(bool Boolean);
 
+  /// \brief Double value functions.
+  bool isDouble() const;
+  double getDouble() const;
+  void setDouble(double Double);
+
   /// \brief Unsigned value functions.
   bool isUnsigned() const;
   unsigned getUnsigned() const;
   void setUnsigned(unsigned Unsigned);
 
   /// \brief String value functions.
   bool isString() const;
   const std::string &getString() const;

 
 private:
   void reset();
 
   /// \brief All supported value types.
   enum ValueType {
     VT_Nothing,
     VT_Boolean,
+    VT_Double,
     VT_Unsigned,
     VT_String,
     VT_Matcher
   };
 
   /// \brief All supported value types.
   union AllValues {
     unsigned Unsigned;
+    double Double;
     bool Boolean;
     std::string *String;
     VariantMatcher *Matcher;
   };
 
   ValueType Type;
   AllValues Value;
 };
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif  // LLVM_CLANG_AST_MATCHERS_DYNAMIC_VARIANT_VALUE_H

lib/ASTMatchers/Dynamic/Diagnostics.cpp

static StringRef errorTypeToFormatString(Diagnostics::ErrorType Type) {
   case Diagnostics::ET_ParserNotAMatcher:
     return "Input value is not a matcher expression.";
   case Diagnostics::ET_ParserInvalidToken:
     return "Invalid token <$0> found when looking for a value.";
   case Diagnostics::ET_ParserMalformedBindExpr:
     return "Malformed bind() expression.";
   case Diagnostics::ET_ParserTrailingCode:
     return "Expected end of code.";
-  case Diagnostics::ET_ParserUnsignedError:
-    return "Error parsing unsigned token: <$0>";
+  case Diagnostics::ET_ParserNumberError:
+    return "Error parsing numeric literal: <$0>";
   case Diagnostics::ET_ParserOverloadedType:
     return "Input value has unresolved overloaded type: $0";
 
   case Diagnostics::ET_None:
     return "<N/A>";
   }
   llvm_unreachable("Unknown ErrorType value.");
 }

lib/ASTMatchers/Dynamic/Marshallers.h

template <> struct ArgTypeTraits<bool> {
   static bool get(const VariantValue &Value) {
     return Value.getBoolean();
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_Boolean);
   }
 };
 
+template <> struct ArgTypeTraits<double> {
+  static bool is(const VariantValue &Value) { return Value.isDouble(); }
+  static double get(const VariantValue &Value) {
+    return Value.getDouble();
+  }
+  static ArgKind getKind() {
+    return ArgKind(ArgKind::AK_Double);
+  }
+};
+
 template <> struct ArgTypeTraits<unsigned> {
   static bool is(const VariantValue &Value) { return Value.isUnsigned(); }
   static unsigned get(const VariantValue &Value) {
     return Value.getUnsigned();
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_Unsigned);
   }

lib/ASTMatchers/Dynamic/Parser.cpp

default:
       break;
     }
 
     Result.Range.End = currentLocation();
     return Result;
   }
 
   /// \brief Consume an unsigned literal.
   void consumeUnsignedLiteral(TokenInfo *Result) {
+    bool isFloatingLiteral = false;
     unsigned Length = 1;
     if (Code.size() > 1) {
       // Consume the 'x' or 'b' radix modifier, if present.
       switch (toLowercase(Code[1])) {
       case 'x': case 'b': Length = 2;
       }
     }
     while (Length < Code.size() && isHexDigit(Code[Length]))
       ++Length;
 
+    // Try to recognize a floating point literal.
+    while (Length < Code.size()) {
+      char c = Code[Length];
+      if (c == '-' || c == '+' || c == '.' || isHexDigit(c)) {
+        isFloatingLiteral = true;
+        Length++;
+      } else {
+        break;
+      }
+    }
+
     Result->Text = Code.substr(0, Length);
     Code = Code.drop_front(Length);
 
+    if (isFloatingLiteral) {
+      char *end;
+      double doubleValue = strtod(Result->Text.str().c_str(), &end);
+      if (*end == 0) {
+        Result->Kind = TokenInfo::TK_Literal;
+        Result->Value = doubleValue;
+        return;
+      }
+    } else {
       unsigned Value;
       if (!Result->Text.getAsInteger(0, Value)) {
         Result->Kind = TokenInfo::TK_Literal;
         Result->Value = Value;
-    } else {
-      SourceRange Range;
-      Range.Start = Result->Range.Start;
-      Range.End = currentLocation();
-      Error->addError(Range, Error->ET_ParserUnsignedError) << Result->Text;
-      Result->Kind = TokenInfo::TK_Error;
-    }
-  }
+        return;
+      }
+    }
+
+    Error->addError(Range, Error->ET_ParserNumberError) << Result->Text;
 
   /// \brief Consume a string literal.
   ///
   /// \c Code must be positioned at the start of the literal (the opening
   /// quote). Consumed until it finds the same closing quote character.
   void consumeStringLiteral(TokenInfo *Result) {
     bool InEscape = false;
     const char Marker = Code[0];

lib/ASTMatchers/Dynamic/VariantValue.cpp

 namespace dynamic {
 
 std::string ArgKind::asString() const {
   switch (getArgKind()) {
   case AK_Matcher:
     return (Twine("Matcher<") + MatcherKind.asStringRef() + ">").str();
   case AK_Boolean:
     return "boolean";
+  case AK_Double:
+    return "double";
   case AK_Unsigned:
     return "unsigned";
   case AK_String:
     return "string";
   }
   llvm_unreachable("unhandled ArgKind");
 }
 

 VariantValue::VariantValue(const VariantValue &Other) : Type(VT_Nothing) {
   *this = Other;
 }
 
 VariantValue::VariantValue(bool Boolean) : Type(VT_Nothing) {
   setBoolean(Boolean);
 }
 
+VariantValue::VariantValue(double Double) : Type(VT_Nothing) {
+  setDouble(Double);
+}
+
 VariantValue::VariantValue(unsigned Unsigned) : Type(VT_Nothing) {
   setUnsigned(Unsigned);
 }
 
 VariantValue::VariantValue(StringRef String) : Type(VT_Nothing) {
   setString(String);
 }
 
 VariantValue::VariantValue(const VariantMatcher &Matcher) : Type(VT_Nothing) {
   setMatcher(Matcher);
 }
 
 VariantValue::~VariantValue() { reset(); }
 
 VariantValue &VariantValue::operator=(const VariantValue &Other) {
   if (this == &Other) return *this;
   reset();
   switch (Other.Type) {
   case VT_Boolean:
     setBoolean(Other.getBoolean());
     break;
+  case VT_Double:
+    setDouble(Other.getDouble());
+    break;
   case VT_Unsigned:
     setUnsigned(Other.getUnsigned());
     break;
   case VT_String:
     setString(Other.getString());
     break;
   case VT_Matcher:
     setMatcher(Other.getMatcher());
void VariantValue::reset() {
   case VT_String:
     delete Value.String;
     break;
   case VT_Matcher:
     delete Value.Matcher;
     break;
   // Cases that do nothing.
   case VT_Boolean:
+  case VT_Double:
   case VT_Unsigned:
   case VT_Nothing:
     break;
   }
   Type = VT_Nothing;
 }
 
 bool VariantValue::isBoolean() const {
   return Type == VT_Boolean;
 }
 
 bool VariantValue::getBoolean() const {
   assert(isBoolean());
   return Value.Boolean;
 }
 
 void VariantValue::setBoolean(bool NewValue) {
   reset();
   Type = VT_Boolean;
   Value.Boolean = NewValue;
 }
 
+bool VariantValue::isDouble() const {
+  return Type == VT_Double;
+}
+
+double VariantValue::getDouble() const {
+  assert(isDouble());
+  return Value.Double;
+}
+
+void VariantValue::setDouble(double NewValue) {
+  reset();
+  Type = VT_Double;
+  Value.Double = NewValue;
+}
+
 bool VariantValue::isUnsigned() const {
   return Type == VT_Unsigned;
 }
 
 unsigned VariantValue::getUnsigned() const {
   assert(isUnsigned());
   return Value.Unsigned;
 }

 bool VariantValue::isConvertibleTo(ArgKind Kind, unsigned *Specificity) const {
   switch (Kind.getArgKind()) {
   case ArgKind::AK_Boolean:
     if (!isBoolean())
       return false;
     *Specificity = 1;
     return true;
 
+  case ArgKind::AK_Double:
+    if (!isDouble())
+      return false;
+    *Specificity = 1;
+    return true;
+
   case ArgKind::AK_Unsigned:
     if (!isUnsigned())
       return false;
     *Specificity = 1;
     return true;
 
   case ArgKind::AK_String:
     if (!isString())
bool VariantValue::isConvertibleTo(ArrayRef<ArgKind> Kinds,
   return MaxSpecificity > 0;
 }
 
 std::string VariantValue::getTypeAsString() const {
   switch (Type) {
   case VT_String: return "String";
   case VT_Matcher: return getMatcher().getTypeAsString();
   case VT_Boolean: return "Boolean";
+  case VT_Double: return "Double";
   case VT_Unsigned: return "Unsigned";
   case VT_Nothing: return "Nothing";
   }
   llvm_unreachable("Invalid Type");
 }
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang

unittests/ASTMatchers/Dynamic/ParserTest.cpp

TEST(ParserTest, ParseBoolean) {
   MockSema Sema;
   Sema.parse("true");
   Sema.parse("false");
   EXPECT_EQ(2U, Sema.Values.size());
   EXPECT_EQ(true, Sema.Values[0].getBoolean());
   EXPECT_EQ(false, Sema.Values[1].getBoolean());
 }
 
+TEST(ParserTest, ParseDouble) {
+  MockSema Sema;
+  Sema.parse("1.0");
+  Sema.parse("2.0f");
+  Sema.parse("34.56e-78");
+  Sema.parse("4.E+6");
+  Sema.parse("1");
+  EXPECT_EQ(5U, Sema.Values.size());
+  EXPECT_EQ(1.0, Sema.Values[0].getDouble());
+  EXPECT_EQ("1:1: Error parsing numeric literal: <2.0f>", Sema.Errors[1]);
+  EXPECT_EQ(34.56e-78, Sema.Values[2].getDouble());
+  EXPECT_EQ(4e+6, Sema.Values[3].getDouble());
+  EXPECT_FALSE(Sema.Values[4].isDouble());
+}
+
 TEST(ParserTest, ParseUnsigned) {
   MockSema Sema;
   Sema.parse("0");
   Sema.parse("123");
   Sema.parse("0x1f");
   Sema.parse("12345678901");
   Sema.parse("1a1");
   EXPECT_EQ(5U, Sema.Values.size());
   EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
   EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
   EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
-  EXPECT_EQ("1:1: Error parsing unsigned token: <12345678901>", Sema.Errors[3]);
-  EXPECT_EQ("1:1: Error parsing unsigned token: <1a1>", Sema.Errors[4]);
+  EXPECT_EQ("1:1: Error parsing numeric literal: <12345678901>", Sema.Errors[3]);
+  EXPECT_EQ("1:1: Error parsing numeric literal: <1a1>", Sema.Errors[4]);
 }
 
 TEST(ParserTest, ParseString) {
   MockSema Sema;
   Sema.parse("\"Foo\"");
   Sema.parse("\"\"");
   Sema.parse("\"Baz");
   EXPECT_EQ(3ULL, Sema.Values.size());

unittests/ASTMatchers/Dynamic/VariantValueTest.cpp

 }
 
 TEST(VariantValueTest, Assignment) {
   VariantValue Value = StringRef("A");
   EXPECT_TRUE(Value.isString());
   EXPECT_EQ("A", Value.getString());
   EXPECT_TRUE(Value.hasValue());
   EXPECT_FALSE(Value.isBoolean());
+  EXPECT_FALSE(Value.isDouble());
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_EQ("String", Value.getTypeAsString());
 
   Value = VariantMatcher::SingleMatcher(recordDecl());
   EXPECT_TRUE(Value.hasValue());
   EXPECT_FALSE(Value.isBoolean());
+  EXPECT_FALSE(Value.isDouble());
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
   EXPECT_TRUE(Value.isMatcher());
   EXPECT_TRUE(Value.getMatcher().hasTypedMatcher<Decl>());
   EXPECT_FALSE(Value.getMatcher().hasTypedMatcher<UnaryOperator>());
   EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
 
   Value = true;
   EXPECT_TRUE(Value.isBoolean());
   EXPECT_EQ(true, Value.getBoolean());
   EXPECT_TRUE(Value.hasValue());
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_FALSE(Value.isString());
 
+  Value = 3.14;
+  EXPECT_TRUE(Value.isDouble());
+  EXPECT_EQ(3.14, Value.getDouble());
+  EXPECT_TRUE(Value.hasValue());
+  EXPECT_FALSE(Value.isBoolean());
+  EXPECT_FALSE(Value.isUnsigned());
+  EXPECT_FALSE(Value.isMatcher());
+  EXPECT_FALSE(Value.isString());
+
   Value = 17;
   EXPECT_TRUE(Value.isUnsigned());
   EXPECT_EQ(17U, Value.getUnsigned());
   EXPECT_FALSE(Value.isBoolean());
+  EXPECT_FALSE(Value.isDouble());
   EXPECT_TRUE(Value.hasValue());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_FALSE(Value.isString());
 
   Value = VariantValue();
   EXPECT_FALSE(Value.hasValue());
   EXPECT_FALSE(Value.isBoolean());
+  EXPECT_FALSE(Value.isDouble());
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_EQ("Nothing", Value.getTypeAsString());
 }
 
 TEST(VariantValueTest, ImplicitBool) {
   VariantValue Value;