[ASTMatchers] Add support for boolean literals

[Lekensteyn]

Summary

Recognize boolean literals for future extensions ("equals(true)").
Note that a specific VariantValue constructor is added to resolve
ambiguity (like "Value = 5") between unsigned and bool.

[aaron.ballman]

LGTM!

[Lekensteyn]

v2: Minor updates (fixed comment: // <Boolean> ... to /// <Boolean, consistently put the boolean code blocks before unsigned).

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> | <Unsigned>
+/// <Literal>           := <StringLiteral> | <Boolean> | <Unsigned>
 /// <StringLiteral>     := "quoted string"
+//  <Boolean>           := true | false
 /// <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_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 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(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 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;
public:
   std::string getTypeAsString() const;
 
 private:
   void reset();
 
   /// \brief All supported value types.
   enum ValueType {
     VT_Nothing,
+    VT_Boolean,
     VT_Unsigned,
     VT_String,
     VT_Matcher
   };
 
   /// \brief All supported value types.
   union AllValues {
     unsigned Unsigned;
+    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/Marshallers.h

template <> struct ArgTypeTraits<unsigned> {
   static unsigned get(const VariantValue &Value) {
     return Value.getUnsigned();
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_Unsigned);
   }
 };
 
+template <> struct ArgTypeTraits<bool> {
+  static bool is(const VariantValue &Value) { return Value.isBoolean(); }
+  static bool get(const VariantValue &Value) {
+    return Value.getBoolean();
+  }
+  static ArgKind getKind() {
+    return ArgKind(ArgKind::AK_Boolean);
+  }
+};
+
 template <> struct ArgTypeTraits<attr::Kind> {
 private:
   static attr::Kind getAttrKind(llvm::StringRef AttrKind) {
     return llvm::StringSwitch<attr::Kind>(AttrKind)
 #define ATTR(X) .Case("attr::" #X, attr:: X)
 #include "clang/Basic/AttrList.inc"
         .Default(attr::Kind(-1));
   }

lib/ASTMatchers/Dynamic/Parser.cpp

default:
             Result.Text = Code.substr(0, TokenLength);
             Code = Code.drop_front(TokenLength);
             return Result;
           }
           if (TokenLength == Code.size() || !isAlphanumeric(Code[TokenLength]))
             break;
           ++TokenLength;
         }
+        if (TokenLength == 4 && Code.startswith("true")) {
+          Result.Kind = TokenInfo::TK_Literal;
+          Result.Value = true;
+        } else if (TokenLength == 5 && Code.startswith("false")) {
+          Result.Kind = TokenInfo::TK_Literal;
+          Result.Value = false;
+        } else {
           Result.Kind = TokenInfo::TK_Ident;
           Result.Text = Code.substr(0, TokenLength);
+        }
         Code = Code.drop_front(TokenLength);
       } else {
         Result.Kind = TokenInfo::TK_InvalidChar;
         Result.Text = Code.substr(0, 1);
         Code = Code.drop_front(1);
       }
       break;
     }

lib/ASTMatchers/Dynamic/VariantValue.cpp

 namespace clang {
 namespace ast_matchers {
 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_Unsigned:
     return "unsigned";
   case AK_String:
     return "string";
   }
   llvm_unreachable("unhandled ArgKind");
 }
 
std::string VariantMatcher::getTypeAsString() const {
   if (Value) return Value->getTypeAsString();
   return "<Nothing>";
 }
 
 VariantValue::VariantValue(const VariantValue &Other) : Type(VT_Nothing) {
   *this = Other;
 }
 
+VariantValue::VariantValue(bool Boolean) : Type(VT_Nothing) {
+  setBoolean(Boolean);
+}
+
 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_Unsigned:
     setUnsigned(Other.getUnsigned());
     break;
   case VT_String:
     setString(Other.getString());
     break;
   case VT_Matcher:
     setMatcher(Other.getMatcher());
void VariantValue::reset() {
   switch (Type) {
   case VT_String:
     delete Value.String;
     break;
   case VT_Matcher:
     delete Value.Matcher;
     break;
   // Cases that do nothing.
+  case VT_Boolean:
   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::isUnsigned() const {
   return Type == VT_Unsigned;
 }
 
 unsigned VariantValue::getUnsigned() const {
   assert(isUnsigned());
   return Value.Unsigned;
 }

 void VariantValue::setMatcher(const VariantMatcher &NewValue) {
   reset();
   Type = VT_Matcher;
   Value.Matcher = new VariantMatcher(NewValue);
 }
 
 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_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_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

public:
   std::vector<std::string> Errors;
   std::vector<VariantValue> Values;
   std::vector<MatcherInfo> Matchers;
   typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
   ExpectedMatchersTy;
   ExpectedMatchersTy ExpectedMatchers;
 };
 
+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, ParseUnsigned) {
   MockSema Sema;
   Sema.parse("0");
   Sema.parse("123");
   Sema.parse("0x1f");
   Sema.parse("12345678901");
   Sema.parse("1a1");
   EXPECT_EQ(5U, Sema.Values.size());

unittests/ASTMatchers/Dynamic/VariantValueTest.cpp

TEST(VariantValueTest, DynTypedMatcher) {
   EXPECT_EQ("Matcher<Expr>", Value.getTypeAsString());
 }
 
 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.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.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 = 17;
   EXPECT_TRUE(Value.isUnsigned());
   EXPECT_EQ(17U, Value.getUnsigned());
+  EXPECT_FALSE(Value.isBoolean());
   EXPECT_TRUE(Value.hasValue());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_FALSE(Value.isString());
 
+  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 = VariantValue();
   EXPECT_FALSE(Value.hasValue());
+  EXPECT_FALSE(Value.isBoolean());
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_EQ("Nothing", Value.getTypeAsString());
 }
 
 TEST(VariantValueTest, ImplicitBool) {
   VariantValue Value;