Make fragile_ivar, check_ptr_vs_member and use_synthetic members

of the Interpreter.

Author: cmtice

lldb/include/lldb/ValueObject/DILAST.h

@@ -92,24 +92,15 @@ class IdentifierNode : public ASTNode {
 class MemberOfNode : public ASTNode {
 public:
   MemberOfNode(uint32_t location, ASTNodeUP base, bool is_arrow,
-               std::string name, lldb::DynamicValueType use_dynamic,
-               bool fragile_ivar, bool use_synth_child,
-               bool check_ptr_vs_member)
+               std::string name)
       : ASTNode(location, NodeKind::eMemberOfNode), m_base(std::move(base)),
-        m_is_arrow(is_arrow), m_field_name(std::move(name)),
-        m_use_dynamic(use_dynamic), m_fragile_ivar(fragile_ivar),
-        m_use_synth_child(use_synth_child),
-        m_check_ptr_vs_member(check_ptr_vs_member) {}
+        m_is_arrow(is_arrow), m_field_name(std::move(name)) {}
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
   ASTNode *GetBase() const { return m_base.get(); }
   bool GetIsArrow() const { return m_is_arrow; }
   llvm::StringRef GetFieldName() const { return llvm::StringRef(m_field_name); }
-  bool GetCheckPtrVsMember() const { return m_check_ptr_vs_member; }
-  bool GetFragileIvar() const { return m_fragile_ivar; }
-  bool GetSynthChild() const { return m_use_synth_child; }
-  lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
 
   static bool classof(const ASTNode *node) {
     return node->GetKind() == NodeKind::eMemberOfNode;
@@ -119,10 +110,6 @@ class MemberOfNode : public ASTNode {
   ASTNodeUP m_base;
   bool m_is_arrow;
   std::string m_field_name;
-  lldb::DynamicValueType m_use_dynamic;
-  bool m_fragile_ivar;
-  bool m_use_synth_child;
-  bool m_check_ptr_vs_member;
 };
 
 class UnaryOpNode : public ASTNode {

lldb/include/lldb/ValueObject/DILEval.h

@@ -41,8 +41,9 @@ lldb::ValueObjectSP LookupGlobalIdentifier(llvm::StringRef name_ref,
 class Interpreter : Visitor {
 public:
   Interpreter(lldb::TargetSP target, llvm::StringRef expr,
-              lldb::DynamicValueType use_dynamic,
-              std::shared_ptr<StackFrame> frame_sp);
+              std::shared_ptr<StackFrame> frame_sp,
+              lldb::DynamicValueType use_dynamic, bool use_synthetic,
+              bool fragile_ivar, bool check_ptr_vs_member);
 
   llvm::Expected<lldb::ValueObjectSP> Evaluate(const ASTNode *node);
 
@@ -56,8 +57,11 @@ class Interpreter : Visitor {
   lldb::TargetSP m_target;
   llvm::StringRef m_expr;
   lldb::ValueObjectSP m_scope;
-  lldb::DynamicValueType m_default_dynamic;
   std::shared_ptr<StackFrame> m_exe_ctx_scope;
+  lldb::DynamicValueType m_use_dynamic;
+  bool m_use_synthetic;
+  bool m_fragile_ivar;
+  bool m_check_ptr_vs_member;
 };
 
 } // namespace lldb_private::dil

lldb/source/Target/StackFrame.cpp

@@ -552,8 +552,9 @@ ValueObjectSP StackFrame::DILGetValueForVariableExpressionPath(
 
   // Evaluate the parsed expression.
   lldb::TargetSP target = this->CalculateTarget();
-  dil::Interpreter interpreter(target, var_expr, use_dynamic,
-                               shared_from_this());
+  dil::Interpreter interpreter(target, var_expr, shared_from_this(),
+                               use_dynamic, !no_synth_child, !no_fragile_ivar,
+                               check_ptr_vs_member);
 
   auto valobj_or_error = interpreter.Evaluate((*tree_or_error).get());
   if (!valobj_or_error) {

lldb/source/ValueObject/DILEval.cpp

@@ -201,10 +201,13 @@ lldb::ValueObjectSP LookupIdentifier(llvm::StringRef name_ref,
 }
 
 Interpreter::Interpreter(lldb::TargetSP target, llvm::StringRef expr,
-                         lldb::DynamicValueType use_dynamic,
-                         std::shared_ptr<StackFrame> frame_sp)
-    : m_target(std::move(target)), m_expr(expr), m_default_dynamic(use_dynamic),
-      m_exe_ctx_scope(frame_sp) {}
+                         std::shared_ptr<StackFrame> frame_sp,
+                         lldb::DynamicValueType use_dynamic, bool use_synthetic,
+                         bool fragile_ivar, bool check_ptr_vs_member)
+    : m_target(std::move(target)), m_expr(expr), m_exe_ctx_scope(frame_sp),
+      m_use_dynamic(use_dynamic), m_use_synthetic(use_synthetic),
+      m_fragile_ivar(fragile_ivar), m_check_ptr_vs_member(check_ptr_vs_member) {
+}
 
 llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode *node) {
   // Evaluate an AST.
@@ -216,7 +219,7 @@ llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode *node) {
 
 llvm::Expected<lldb::ValueObjectSP>
 Interpreter::Visit(const IdentifierNode *node) {
-  lldb::DynamicValueType use_dynamic = m_default_dynamic;
+  lldb::DynamicValueType use_dynamic = m_use_dynamic;
 
   lldb::ValueObjectSP identifier =
       LookupIdentifier(node->GetName(), m_exe_ctx_scope, use_dynamic);
@@ -245,7 +248,7 @@ Interpreter::Visit(const UnaryOpNode *node) {
 
   switch (node->kind()) {
   case UnaryOpKind::Deref: {
-    lldb::ValueObjectSP dynamic_rhs = rhs->GetDynamicValue(m_default_dynamic);
+    lldb::ValueObjectSP dynamic_rhs = rhs->GetDynamicValue(m_use_dynamic);
     if (dynamic_rhs)
       rhs = dynamic_rhs;
 
@@ -278,14 +281,10 @@ Interpreter::Visit(const MemberOfNode *node) {
   if (!base_or_err)
     return base_or_err;
   lldb::ValueObjectSP base = *base_or_err;
-  bool check_ptr_vs_member = node->GetCheckPtrVsMember();
-  bool fragile_ivar = node->GetFragileIvar();
-  bool synth_child = node->GetSynthChild();
-  lldb::DynamicValueType use_dynamic = node->GetUseDynamic();
 
   // Perform some basic type & correctness checking.
   if (node->GetIsArrow()) {
-    if (!fragile_ivar) {
+    if (!m_fragile_ivar) {
       // Make sure we aren't trying to deref an objective
       // C ivar if this is not allowed
       const uint32_t pointer_type_flags =
@@ -323,7 +322,7 @@ Interpreter::Visit(const MemberOfNode *node) {
     }
   }
 
-  if (check_ptr_vs_member) {
+  if (m_check_ptr_vs_member) {
     bool expr_is_ptr = node->GetIsArrow();
     bool base_is_ptr = base->IsPointerType();
 
@@ -349,13 +348,13 @@ Interpreter::Visit(const MemberOfNode *node) {
   lldb::ValueObjectSP field_obj =
       base->GetChildMemberWithName(node->GetFieldName());
   if (!field_obj) {
-    if (synth_child) {
+    if (m_use_synthetic) {
       field_obj = base->GetSyntheticValue();
       if (field_obj)
         field_obj = field_obj->GetChildMemberWithName(node->GetFieldName());
     }
 
-    if (!synth_child || !field_obj) {
+    if (!m_use_synthetic || !field_obj) {
       std::string errMsg = llvm::formatv(
           "no member named '{0}' in {1}", node->GetFieldName(),
           base->GetCompilerType().GetFullyUnqualifiedType().TypeDescription());
@@ -365,9 +364,9 @@ Interpreter::Visit(const MemberOfNode *node) {
   }
 
   if (field_obj && field_obj->GetName() == node->GetFieldName()) {
-    if (use_dynamic != lldb::eNoDynamicValues) {
+    if (m_use_dynamic != lldb::eNoDynamicValues) {
       lldb::ValueObjectSP dynamic_val_sp =
-          field_obj->GetDynamicValue(use_dynamic);
+          field_obj->GetDynamicValue(m_use_dynamic);
       if (dynamic_val_sp)
         field_obj = dynamic_val_sp;
     }

lldb/source/ValueObject/DILParser.cpp

@@ -131,8 +131,7 @@ ASTNodeUP DILParser::ParsePostfixExpression() {
     std::string member_id = ParseIdExpression();
     lhs = std::make_unique<MemberOfNode>(
         member_token.GetLocation(), std::move(lhs),
-        token.GetKind() == Token::arrow, member_id, UseDynamic(),
-        m_fragile_ivar, m_use_synthetic, m_check_ptr_vs_member);
+        token.GetKind() == Token::arrow, member_id);
   }
   return lhs;
 }