[LLDB] Add boolean literals to DIL. (llvm#157992)

This adds the ability to recognize (and create ValueObjects for) boolean
literals ("true", "false") to DIL. This is a preliminary step to adding
type casting (and also for the ternary op).

Author: cmtice

lldb/docs/dil-expr-lang.ebnf

@@ -36,6 +36,7 @@ postfix_expression = primary_expression
                    | postfix_expression "->" id_expression ;
 
 primary_expression = numeric_literal
+                   | boolean_literal
                    | id_expression
                    | "(" expression ")" ;
 
@@ -53,6 +54,8 @@ identifier = ? C99 Identifier ? ;
 numeric_literal = ? Integer constant: hexademical, decimal, octal, binary ?
                 | ? Floating constant ? ;
 
+boolean_literal = "true" | "false" ;
+
 register = "$" ? Register name ? ;
 
 nested_name_specifier = type_name "::"

lldb/include/lldb/ValueObject/DILAST.h

@@ -22,6 +22,7 @@ enum class NodeKind {
   eArraySubscriptNode,
   eBinaryOpNode,
   eBitExtractionNode,
+  eBooleanLiteralNode,
   eCStyleCastNode,
   eErrorNode,
   eFloatLiteralNode,
@@ -290,6 +291,24 @@ class FloatLiteralNode : public ASTNode {
   llvm::APFloat m_value;
 };
 
+class BooleanLiteralNode : public ASTNode {
+public:
+  BooleanLiteralNode(uint32_t location, bool value)
+      : ASTNode(location, NodeKind::eBooleanLiteralNode), m_value(value) {}
+
+  llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
+
+  bool IsConstLiteral() const override { return true; }
+  bool GetValue() const & { return m_value; }
+
+  static bool classof(const ASTNode *node) {
+    return node->GetKind() == NodeKind::eBooleanLiteralNode;
+  }
+
+private:
+  bool m_value;
+};
+
 class CStyleCastNode : public ASTNode {
 public:
   CStyleCastNode(uint32_t location, CompilerType type, ASTNodeUP operand,
@@ -337,6 +356,8 @@ class Visitor {
   virtual llvm::Expected<lldb::ValueObjectSP>
   Visit(const FloatLiteralNode *node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
+  Visit(const BooleanLiteralNode *node) = 0;
+  virtual llvm::Expected<lldb::ValueObjectSP>
   Visit(const CStyleCastNode *node) = 0;
 };
 

lldb/include/lldb/ValueObject/DILEval.h

@@ -62,6 +62,8 @@ class Interpreter : Visitor {
   llvm::Expected<lldb::ValueObjectSP>
   Visit(const FloatLiteralNode *node) override;
   llvm::Expected<lldb::ValueObjectSP>
+  Visit(const BooleanLiteralNode *node) override;
+  llvm::Expected<lldb::ValueObjectSP>
   Visit(const CStyleCastNode *node) override;
 
   lldb::ValueObjectSP

lldb/include/lldb/ValueObject/DILLexer.h

@@ -34,6 +34,8 @@ class Token {
     greatergreater,
     identifier,
     integer_constant,
+    kw_false,
+    kw_true,
     l_paren,
     l_square,
     lessless,

lldb/include/lldb/ValueObject/DILParser.h

@@ -163,6 +163,7 @@ class DILParser {
   ASTNodeUP ParseNumericLiteral();
   ASTNodeUP ParseIntegerLiteral();
   ASTNodeUP ParseFloatingPointLiteral();
+  ASTNodeUP ParseBooleanLiteral();
 
   ASTNodeUP ParseCastExpression();
   std::optional<CompilerType> ParseTypeId(bool must_be_type_id = false);

lldb/source/ValueObject/DILAST.cpp

@@ -78,6 +78,11 @@ llvm::Expected<lldb::ValueObjectSP> FloatLiteralNode::Accept(Visitor *v) const {
   return v->Visit(this);
 }
 
+llvm::Expected<lldb::ValueObjectSP>
+BooleanLiteralNode::Accept(Visitor *v) const {
+  return v->Visit(this);
+}
+
 llvm::Expected<lldb::ValueObjectSP> CStyleCastNode::Accept(Visitor *v) const {
   return v->Visit(this);
 }

lldb/source/ValueObject/DILEval.cpp

@@ -1296,6 +1296,12 @@ Interpreter::Visit(const FloatLiteralNode *node) {
                                                   "result");
 }
 
+llvm::Expected<lldb::ValueObjectSP>
+Interpreter::Visit(const BooleanLiteralNode *node) {
+  bool value = node->GetValue();
+  return ValueObject::CreateValueObjectFromBool(m_target, value, "result");
+}
+
 llvm::Expected<CompilerType> Interpreter::VerifyCStyleCastType(
     lldb::ValueObjectSP &operand, CompilerType &op_type,
     CompilerType target_type, CastPromoKind &promo_kind,

lldb/source/ValueObject/DILLexer.cpp

@@ -40,6 +40,10 @@ llvm::StringRef Token::GetTokenName(Kind kind) {
     return "identifier";
   case Kind::integer_constant:
     return "integer_constant";
+  case Kind::kw_false:
+    return "false";
+  case Kind::kw_true:
+    return "true";
   case Kind::l_paren:
     return "l_paren";
   case Kind::l_square:
@@ -150,8 +154,14 @@ llvm::Expected<Token> DILLexer::Lex(llvm::StringRef expr,
     return Token(kind, maybe_number->str(), position);
   }
   std::optional<llvm::StringRef> maybe_word = IsWord(expr, remainder);
-  if (maybe_word)
-    return Token(Token::identifier, maybe_word->str(), position);
+  if (maybe_word) {
+    llvm::StringRef word = *maybe_word;
+    Token::Kind kind = llvm::StringSwitch<Token::Kind>(word)
+                           .Case("false", Token::kw_false)
+                           .Case("true", Token::kw_true)
+                           .Default(Token::identifier);
+    return Token(kind, word.str(), position);
+  }
 
   constexpr std::pair<Token::Kind, const char *> operators[] = {
       {Token::arrow, "->"},

lldb/source/ValueObject/DILParser.cpp

@@ -425,12 +425,15 @@ ASTNodeUP DILParser::ParsePostfixExpression() {
 //
 //  primary_expression:
 //    numeric_literal
+//    boolean_literal
 //    id_expression
 //    "(" expression ")"
 //
 ASTNodeUP DILParser::ParsePrimaryExpression() {
   if (CurToken().IsOneOf({Token::integer_constant, Token::float_constant}))
     return ParseNumericLiteral();
+  if (CurToken().IsOneOf({Token::kw_true, Token::kw_false}))
+    return ParseBooleanLiteral();
   if (CurToken().IsOneOf(
           {Token::coloncolon, Token::identifier, Token::l_paren})) {
     // Save the source location for the diagnostics message.
@@ -811,6 +814,20 @@ std::string DILParser::ParseUnqualifiedId() {
   return identifier;
 }
 
+// Parse an boolean_literal.
+//
+//  boolean_literal:
+//    "true"
+//    "false"
+//
+ASTNodeUP DILParser::ParseBooleanLiteral() {
+  ExpectOneOf(std::vector<Token::Kind>{Token::kw_true, Token::kw_false});
+  uint32_t loc = CurToken().GetLocation();
+  bool literal_value = CurToken().Is(Token::kw_true);
+  m_dil_lexer.Advance();
+  return std::make_unique<BooleanLiteralNode>(loc, literal_value);
+}
+
 CompilerType
 DILParser::ResolveTypeDeclarators(CompilerType type,
                                   const std::vector<Token> &ptr_operators) {

lldb/test/API/commands/frame/var-dil/expr/Literals/TestFrameVarDILLiterals.py

@@ -19,6 +19,10 @@ def test_literals(self):
 
         self.runCmd("settings set target.experimental.use-DIL true")
 
+        # Check boolean literals parsing
+        self.expect_var_path("true", value="true", type="bool")
+        self.expect_var_path("false", value="false", type="bool")
+
         # Check number literals parsing
         self.expect_var_path("1.0", value="1", type="double")
         self.expect_var_path("1.0f", value="1", type="float")