Support expressions in the context of a reference

[emrekultursay]

Summary

...type variable by dereferencing the variable before
evaluating the expression.

[emrekultursay]

Rebased

[emrekultursay]

re-rebase

[labath]

lldb/test/API/commands/expression/context-object/TestContextObject.py

20–21

wrap this in something like: for obj in "cpp_struct","cpp_struct_ref" instead of duplicating everything?

[emrekultursay]

Use loop instead of code duplication in test

[emrekultursay]

Thanks. Please submit the change on my behalf.

lldb/source/Expression/UserExpression.cpp

 UserExpression::Evaluate(ExecutionContext &exe_ctx,
                          const EvaluateExpressionOptions &options,
                          llvm::StringRef expr, llvm::StringRef prefix,
                          lldb::ValueObjectSP &result_valobj_sp, Status &error,
                          std::string *fixed_expression, ValueObject *ctx_obj) {
   Log *log(GetLog(LLDBLog::Expressions | LLDBLog::Step));
 
   if (ctx_obj) {
-    static unsigned const ctx_type_mask =
-        lldb::TypeFlags::eTypeIsClass | lldb::TypeFlags::eTypeIsStructUnion;
+    static unsigned const ctx_type_mask = lldb::TypeFlags::eTypeIsClass |
+                                          lldb::TypeFlags::eTypeIsStructUnion |
+                                          lldb::TypeFlags::eTypeIsReference;
     if (!(ctx_obj->GetTypeInfo() & ctx_type_mask)) {
       LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a context object of "
                     "an invalid type, can't run expressions.");
       error.SetErrorString("a context object of an invalid type passed");
       return lldb::eExpressionSetupError;
     }
   }
 
+  if (ctx_obj && ctx_obj->GetTypeInfo() & lldb::TypeFlags::eTypeIsReference) {
+    Status error;
+    lldb::ValueObjectSP deref_ctx_sp = ctx_obj->Dereference(error);
+    if (!error.Success()) {
+      LLDB_LOG(log, "== [UserExpression::Evaluate] Passed a context object of "
+                    "a reference type that can't be dereferenced, can't run "
+                    "expressions.");
+      error.SetErrorString(
+          "passed context object of an reference type cannot be deferenced");
+      return lldb::eExpressionSetupError;
+    }
+
+    ctx_obj = deref_ctx_sp.get();
+  }
+
   lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
   lldb::LanguageType language = options.GetLanguage();
   const ResultType desired_type = options.DoesCoerceToId()
                                       ? UserExpression::eResultTypeId
                                       : UserExpression::eResultTypeAny;
   lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;
 
   Target *target = exe_ctx.GetTargetPtr();

lldb/test/API/commands/expression/context-object/TestContextObject.py

class ContextObjectTestCase(TestBase):
     def test_context_object(self):
         """Tests expression evaluation in context of an object."""
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         #
-        # Test C++ struct variable
+        # Test C++ struct variable and reference-to-struct variable
         #
-
-        obj_val = frame.FindVariable("cpp_struct")
+        for obj in "cpp_struct", "cpp_struct_ref":
+            obj_val = frame.FindVariable(obj)
             self.assertTrue(obj_val.IsValid())
 
             # Test an empty expression evaluation
             value = obj_val.EvaluateExpression("")
             self.assertFalse(value.IsValid())
             self.assertFalse(value.GetError().Success())
 
             # Test retrieveing of a field (not a local with the same name)
             value = obj_val.EvaluateExpression("field")
             self.assertTrue(value.IsValid())
             self.assertSuccess(value.GetError())
             self.assertEqual(value.GetValueAsSigned(), 1111)
 
             # Test functions evaluation
             value = obj_val.EvaluateExpression("function()")
             self.assertTrue(value.IsValid())
             self.assertSuccess(value.GetError())
             self.assertEqual(value.GetValueAsSigned(), 2222)
 
             # Test that we retrieve the right global
             value = obj_val.EvaluateExpression("global.field")
             self.assertTrue(value.IsValid())
             self.assertSuccess(value.GetError())
             self.assertEqual(value.GetValueAsSigned(), 1111)
 
         #
         # Test C++ union variable
         #
 
         obj_val = frame.FindVariable("cpp_union")
         self.assertTrue(obj_val.IsValid())
 

lldb/test/API/commands/expression/context-object/main.cpp

 
 int global = 3333;
 
 int main()
 {
   cpp_namespace::CppStruct cpp_struct = cpp_namespace::GetCppStruct();
   cpp_struct.function();
 
+  cpp_namespace::CppStruct &cpp_struct_ref = cpp_struct;
+  cpp_struct_ref.function();
+
   int field = 4444;
 
   cpp_namespace::CppUnion cpp_union;
   cpp_union.field_int = 5555;
 
   int cpp_scalar = 6666;
 
   cpp_namespace::CppStruct cpp_array[16];
 
   cpp_namespace::CppStruct *cpp_pointer = cpp_namespace::GetCppStructPtr();
 
   return 0; // Break here
 }