Address reviewer comments:

	- change references to C-style casting to just casting
	- add comments to cast enumeration types
	- use early-return

Author: cmtice

lldb/include/lldb/ValueObject/DILAST.h

@@ -21,7 +21,7 @@ enum class NodeKind {
   eArraySubscriptNode,
   eBitExtractionNode,
   eBooleanLiteralNode,
-  eCStyleCastNode,
+  eCastNode,
   eErrorNode,
   eFloatLiteralNode,
   eIdentifierNode,
@@ -36,12 +36,12 @@ enum class UnaryOpKind {
   Deref,  // "*"
 };
 
-/// The C-Style casts allowed by DIL.
-enum class CStyleCastKind {
-  eEnumeration,
-  eNullptr,
-  eReference,
-  eNone,
+/// The type casts allowed by DIL.
+enum class CastKind {
+  eEnumeration, /// Casting from a scalar to an enumeration type
+  eNullptr,     /// Casting to a nullptr type
+  eReference,   /// Casting to a reference type
+  eNone,        /// Type promotion casting
 };
 
 /// Forward declaration, for use in DIL AST nodes. Definition is at the very
@@ -253,27 +253,27 @@ class BooleanLiteralNode : public ASTNode {
   bool m_value;
 };
 
-class CStyleCastNode : public ASTNode {
+class CastNode : public ASTNode {
 public:
-  CStyleCastNode(uint32_t location, CompilerType type, ASTNodeUP operand,
-                 CStyleCastKind kind)
-      : ASTNode(location, NodeKind::eCStyleCastNode), m_type(type),
+  CastNode(uint32_t location, CompilerType type, ASTNodeUP operand,
+                 CastKind kind)
+      : ASTNode(location, NodeKind::eCastNode), m_type(type),
         m_operand(std::move(operand)), m_cast_kind(kind) {}
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
   CompilerType GetType() const { return m_type; }
   ASTNode *GetOperand() const { return m_operand.get(); }
-  CStyleCastKind GetCastKind() const { return m_cast_kind; }
+  CastKind GetCastKind() const { return m_cast_kind; }
 
   static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eCStyleCastNode;
+    return node->GetKind() == NodeKind::eCastNode;
   }
 
 private:
   CompilerType m_type;
   ASTNodeUP m_operand;
-  CStyleCastKind m_cast_kind;
+  CastKind m_cast_kind;
 };
 
 /// This class contains one Visit method for each specialized type of
@@ -300,7 +300,7 @@ class Visitor {
   virtual llvm::Expected<lldb::ValueObjectSP>
   Visit(const BooleanLiteralNode *node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const CStyleCastNode *node) = 0;
+  Visit(const CastNode *node) = 0;
 };
 
 } // namespace lldb_private::dil

lldb/include/lldb/ValueObject/DILEval.h

@@ -61,7 +61,7 @@ class Interpreter : Visitor {
   llvm::Expected<lldb::ValueObjectSP>
   Visit(const BooleanLiteralNode *node) override;
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const CStyleCastNode *node) override;
+  Visit(const CastNode *node) override;
 
   llvm::Expected<CompilerType>
   PickIntegerType(lldb::TypeSystemSP type_system,

lldb/source/ValueObject/DILAST.cpp

@@ -51,7 +51,7 @@ BooleanLiteralNode::Accept(Visitor *v) const {
   return v->Visit(this);
 }
 
-llvm::Expected<lldb::ValueObjectSP> CStyleCastNode::Accept(Visitor *v) const {
+llvm::Expected<lldb::ValueObjectSP> CastNode::Accept(Visitor *v) const {
   return v->Visit(this);
 }
 

lldb/source/ValueObject/DILEval.cpp

@@ -609,7 +609,7 @@ Interpreter::Visit(const BooleanLiteralNode *node) {
 }
 
 llvm::Expected<lldb::ValueObjectSP>
-Interpreter::Visit(const CStyleCastNode *node) {
+Interpreter::Visit(const CastNode *node) {
   auto operand_or_err = Evaluate(node->GetOperand());
   if (!operand_or_err)
     return operand_or_err;

lldb/source/ValueObject/DILParser.cpp

@@ -93,43 +93,44 @@ ASTNodeUP DILParser::ParseExpression() { return ParseCastExpression(); }
 //   "(" type_id ")" cast_expression
 
 ASTNodeUP DILParser::ParseCastExpression() {
-  // This can be a C-style cast, try parsing the contents as a type declaration.
-  if (CurToken().Is(Token::l_paren)) {
-    Token token = CurToken();
-    uint32_t loc = token.GetLocation();
+  if (!CurToken().Is(Token::l_paren))
+    return ParseUnaryExpression();
 
-    // Enable lexer backtracking, so that we can rollback in case it's not
-    // actually a type declaration.
+  // This could be a type cast, try parsing the contents as a type declaration.
+  Token token = CurToken();
+  uint32_t loc = token.GetLocation();
 
-    // Start tentative parsing (save token location/idx, for possible rollback).
-    uint32_t save_token_idx = m_dil_lexer.GetCurrentTokenIdx();
+  // Enable lexer backtracking, so that we can rollback in case it's not
+  // actually a type declaration.
 
-    // Consume the token only after enabling the backtracking.
-    m_dil_lexer.Advance();
+  // Start tentative parsing (save token location/idx, for possible rollback).
+  uint32_t save_token_idx = m_dil_lexer.GetCurrentTokenIdx();
 
-    // Try parsing the type declaration. If the returned value is not valid,
-    // then we should rollback and try parsing the expression.
-    auto type_id = ParseTypeId();
-    if (type_id) {
-      // Successfully parsed the type declaration. Commit the backtracked
-      // tokens and parse the cast_expression.
+  // Consume the token only after enabling the backtracking.
+  m_dil_lexer.Advance();
 
-      if (!type_id.value().IsValid())
-        return std::make_unique<ErrorNode>();
+  // Try parsing the type declaration. If the returned value is not valid,
+  // then we should rollback and try parsing the expression.
+  auto type_id = ParseTypeId();
+  if (type_id) {
+    // Successfully parsed the type declaration. Commit the backtracked
+    // tokens and parse the cast_expression.
 
-      Expect(Token::r_paren);
-      m_dil_lexer.Advance();
-      auto rhs = ParseCastExpression();
+    if (!type_id.value().IsValid())
+      return std::make_unique<ErrorNode>();
 
-      return std::make_unique<CStyleCastNode>(
-          loc, type_id.value(), std::move(rhs), CStyleCastKind::eNone);
-    }
+    Expect(Token::r_paren);
+    m_dil_lexer.Advance();
+    auto rhs = ParseCastExpression();
 
-    // Failed to parse the contents of the parentheses as a type declaration.
-    // Rollback the lexer and try parsing it as unary_expression.
-    TentativeParsingRollback(save_token_idx);
+    return std::make_unique<CastNode>(
+        loc, type_id.value(), std::move(rhs), CastKind::eNone);
   }
 
+  // Failed to parse the contents of the parentheses as a type declaration.
+  // Rollback the lexer and try parsing it as unary_expression.
+  TentativeParsingRollback(save_token_idx);
+
   return ParseUnaryExpression();
 }