Rename rhs to operand, remove extra check and return ValueObject::Dereference error, cleanup code.

Author: kuilpd

lldb/include/lldb/ValueObject/DILAST.h

@@ -90,22 +90,22 @@ class IdentifierNode : public ASTNode {
 
 class UnaryOpNode : public ASTNode {
 public:
-  UnaryOpNode(uint32_t location, UnaryOpKind kind, ASTNodeUP rhs)
+  UnaryOpNode(uint32_t location, UnaryOpKind kind, ASTNodeUP operand)
       : ASTNode(location, NodeKind::eUnaryOpNode), m_kind(kind),
-        m_rhs(std::move(rhs)) {}
+        m_operand(std::move(operand)) {}
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
   UnaryOpKind kind() const { return m_kind; }
-  ASTNode *rhs() const { return m_rhs.get(); }
+  ASTNode *operand() const { return m_operand.get(); }
 
   static bool classof(const ASTNode *node) {
     return node->GetKind() == NodeKind::eUnaryOpNode;
   }
 
 private:
   UnaryOpKind m_kind;
-  ASTNodeUP m_rhs;
+  ASTNodeUP m_operand;
 };
 
 /// This class contains one Visit method for each specialized type of

lldb/source/ValueObject/DILEval.cpp

@@ -237,10 +237,10 @@ Interpreter::Visit(const IdentifierNode *node) {
 llvm::Expected<lldb::ValueObjectSP>
 Interpreter::Visit(const UnaryOpNode *node) {
   Status error;
-  auto rhs_or_err = Evaluate(node->rhs());
-  if (!rhs_or_err) {
+  auto rhs_or_err = Evaluate(node->operand());
+  if (!rhs_or_err)
     return rhs_or_err;
-  }
+
   lldb::ValueObjectSP rhs = *rhs_or_err;
 
   switch (node->kind()) {
@@ -249,30 +249,26 @@ Interpreter::Visit(const UnaryOpNode *node) {
     if (dynamic_rhs)
       rhs = dynamic_rhs;
 
-    CompilerType rhs_type = rhs->GetCompilerType();
-    if (!rhs_type.IsReferenceType() && !rhs_type.IsPointerType())
-      return llvm::make_error<DILDiagnosticError>(
-          m_expr, "not a pointer or reference type",
-          node->rhs()->GetLocation());
-
-    if (rhs_type.IsPointerToVoid()) {
+    if (rhs->GetCompilerType().IsPointerToVoid()) {
       return llvm::make_error<DILDiagnosticError>(
           m_expr, "indirection not permitted on operand of type 'void *'",
           node->GetLocation());
     }
+
     lldb::ValueObjectSP child_sp = rhs->Dereference(error);
-    if (error.Success())
-      rhs = child_sp;
+    if (error.Fail())
+      return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(),
+                                                  node->GetLocation());
 
-    return rhs;
+    return child_sp;
   }
   case UnaryOpKind::AddrOf: {
     Status error;
     lldb::ValueObjectSP value = rhs->AddressOf(error);
-    if (error.Fail()) {
+    if (error.Fail())
       return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(),
                                                   node->GetLocation());
-    }
+
     return value;
   }
   }
@@ -282,4 +278,4 @@ Interpreter::Visit(const UnaryOpNode *node) {
       m_expr, "invalid ast: unexpected binary operator", node->GetLocation());
 }
 
-} // namespace lldb_private::dil
+} // namespace lldb_private::dil