Remove unnecessary arguments, add error output from GetDereferencedType.

Author: kuilpd

lldb/include/lldb/Symbol/CompilerType.h

@@ -439,14 +439,13 @@ class CompilerType {
                                    uint32_t *bitfield_bit_size_ptr = nullptr,
                                    bool *is_bitfield_ptr = nullptr) const;
 
-  llvm::Expected<CompilerType> GetDereferencedType(
-      ExecutionContext *exe_ctx, bool transparent_pointers,
-      bool omit_empty_base_classes, bool ignore_array_bounds,
-      std::string &child_name, uint32_t &child_byte_size,
-      int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
-      uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
-      bool &child_is_deref_of_parent, ValueObject *valobj,
-      uint64_t &language_flags, bool &type_valid) const;
+  llvm::Expected<CompilerType>
+  GetDereferencedType(ExecutionContext *exe_ctx, std::string &child_name,
+                      uint32_t &child_byte_size, int32_t &child_byte_offset,
+                      uint32_t &child_bitfield_bit_size,
+                      uint32_t &child_bitfield_bit_offset,
+                      bool &child_is_base_class, ValueObject *valobj,
+                      uint64_t &language_flags, bool &type_valid) const;
 
   llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(
       ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,

lldb/include/lldb/Symbol/TypeSystem.h

@@ -366,11 +366,9 @@ class TypeSystem : public PluginInterface,
 
   virtual llvm::Expected<CompilerType> GetDereferencedType(
       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-      bool transparent_pointers, bool omit_empty_base_classes,
-      bool ignore_array_bounds, std::string &child_name,
-      uint32_t &child_byte_size, int32_t &child_byte_offset,
-      uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
-      bool &child_is_base_class, bool &child_is_deref_of_parent,
+      std::string &child_name, uint32_t &child_byte_size,
+      int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
+      uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
       ValueObject *valobj, uint64_t &language_flags, bool &type_valid) = 0;
 
   virtual llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

@@ -6203,21 +6203,19 @@ uint32_t TypeSystemClang::GetNumPointeeChildren(clang::QualType type) {
 
 llvm::Expected<CompilerType> TypeSystemClang::GetDereferencedType(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-    bool transparent_pointers, bool omit_empty_base_classes,
-    bool ignore_array_bounds, std::string &child_name,
-    uint32_t &child_byte_size, int32_t &child_byte_offset,
-    uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
-    bool &child_is_base_class, bool &child_is_deref_of_parent,
+    std::string &child_name, uint32_t &child_byte_size,
+    int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
+    uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
     ValueObject *valobj, uint64_t &language_flags, bool &type_valid) {
   type_valid = IsPointerOrReferenceType(type, nullptr) ||
                IsArrayType(type, nullptr, nullptr, nullptr);
   if (!type_valid)
-    return CompilerType();
+    return llvm::createStringError("not a pointer, reference or array type");
+  bool child_is_deref_of_parent;
   return GetChildCompilerTypeAtIndex(
-      type, exe_ctx, 0, transparent_pointers, omit_empty_base_classes,
-      ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
-      child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
-      child_is_deref_of_parent, valobj, language_flags);
+      type, exe_ctx, 0, false, true, false, child_name, child_byte_size,
+      child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
+      child_is_base_class, child_is_deref_of_parent, valobj, language_flags);
 }
 
 llvm::Expected<CompilerType> TypeSystemClang::GetChildCompilerTypeAtIndex(
@@ -6584,8 +6582,6 @@ llvm::Expected<CompilerType> TypeSystemClang::GetChildCompilerTypeAtIndex(
             return size_or_err.takeError();
           child_byte_size = *size_or_err;
           child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
-          if (idx == 0)
-            child_is_deref_of_parent = true;
           return element_type;
         }
       }

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

@@ -891,11 +891,9 @@ class TypeSystemClang : public TypeSystem {
 
   llvm::Expected<CompilerType> GetDereferencedType(
       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-      bool transparent_pointers, bool omit_empty_base_classes,
-      bool ignore_array_bounds, std::string &child_name,
-      uint32_t &child_byte_size, int32_t &child_byte_offset,
-      uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
-      bool &child_is_base_class, bool &child_is_deref_of_parent,
+      std::string &child_name, uint32_t &child_byte_size,
+      int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
+      uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
       ValueObject *valobj, uint64_t &language_flags, bool &type_valid) override;
 
   llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(

lldb/source/Symbol/CompilerType.cpp

@@ -913,21 +913,17 @@ uint32_t CompilerType::GetIndexOfFieldWithName(
 }
 
 llvm::Expected<CompilerType> CompilerType::GetDereferencedType(
-    ExecutionContext *exe_ctx, bool transparent_pointers,
-    bool omit_empty_base_classes, bool ignore_array_bounds,
-    std::string &child_name, uint32_t &child_byte_size,
-    int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
-    uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
-    bool &child_is_deref_of_parent, ValueObject *valobj,
-    uint64_t &language_flags, bool &type_valid) const {
+    ExecutionContext *exe_ctx, std::string &child_name,
+    uint32_t &child_byte_size, int32_t &child_byte_offset,
+    uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
+    bool &child_is_base_class, ValueObject *valobj, uint64_t &language_flags,
+    bool &type_valid) const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->GetDereferencedType(
-          m_type, exe_ctx, transparent_pointers, omit_empty_base_classes,
-          ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
+          m_type, exe_ctx, child_name, child_byte_size, child_byte_offset,
           child_bitfield_bit_size, child_bitfield_bit_offset,
-          child_is_base_class, child_is_deref_of_parent, valobj, language_flags,
-          type_valid);
+          child_is_base_class, valobj, language_flags, type_valid);
   return CompilerType();
 }
 

lldb/source/ValueObject/ValueObject.cpp

@@ -2844,16 +2844,12 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
   if (m_deref_valobj)
     return m_deref_valobj->GetSP();
 
-  bool omit_empty_base_classes = true;
-  bool ignore_array_bounds = false;
   std::string child_name_str;
   uint32_t child_byte_size = 0;
   int32_t child_byte_offset = 0;
   uint32_t child_bitfield_bit_size = 0;
   uint32_t child_bitfield_bit_offset = 0;
   bool child_is_base_class = false;
-  bool child_is_deref_of_parent = false;
-  const bool transparent_pointers = false;
   CompilerType compiler_type = GetCompilerType();
   uint64_t language_flags = 0;
   bool is_valid_dereference_type = false;
@@ -2862,17 +2858,20 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
 
   CompilerType child_compiler_type;
   auto child_compiler_type_or_err = compiler_type.GetDereferencedType(
-      &exe_ctx, transparent_pointers, omit_empty_base_classes,
-      ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
+      &exe_ctx, child_name_str, child_byte_size, child_byte_offset,
       child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
-      child_is_deref_of_parent, this, language_flags,
-      is_valid_dereference_type);
+      this, language_flags, is_valid_dereference_type);
 
-  if (!child_compiler_type_or_err && is_valid_dereference_type)
-    LLDB_LOG_ERROR(GetLog(LLDBLog::Types),
-                   child_compiler_type_or_err.takeError(),
-                   "could not find child: {0}");
-  else
+  std::string deref_error;
+  if (!child_compiler_type_or_err) {
+    auto err = child_compiler_type_or_err.takeError();
+    if (err.isA<llvm::StringError>()) {
+      deref_error = llvm::toString(std::move(err));
+      LLDB_LOG_ERROR(GetLog(LLDBLog::Types),
+                     llvm::createStringError(deref_error),
+                     "could not find child: {0}");
+    }
+  } else
     child_compiler_type = *child_compiler_type_or_err;
 
   if (is_valid_dereference_type) {
@@ -2884,8 +2883,7 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
       m_deref_valobj = new ValueObjectChild(
           *this, child_compiler_type, child_name, child_byte_size,
           child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
-          child_is_base_class, child_is_deref_of_parent, eAddressTypeInvalid,
-          language_flags);
+          child_is_base_class, true, eAddressTypeInvalid, language_flags);
     }
 
     // In case of incomplete child compiler type, use the pointee type and try
@@ -2905,8 +2903,8 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
           m_deref_valobj = new ValueObjectChild(
               *this, child_compiler_type, child_name, child_byte_size,
               child_byte_offset, child_bitfield_bit_size,
-              child_bitfield_bit_offset, child_is_base_class,
-              child_is_deref_of_parent, eAddressTypeInvalid, language_flags);
+              child_bitfield_bit_offset, child_is_base_class, true,
+              eAddressTypeInvalid, language_flags);
         }
       }
     }
@@ -2924,13 +2922,13 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
     StreamString strm;
     GetExpressionPath(strm);
 
-    if (is_valid_dereference_type)
+    if (deref_error.empty())
       error = Status::FromErrorStringWithFormat(
           "dereference failed: (%s) %s",
           GetTypeName().AsCString("<invalid type>"), strm.GetData());
     else
       error = Status::FromErrorStringWithFormat(
-          "not a pointer or reference type: (%s) %s",
+          "dereference failed: %s: (%s) %s", deref_error.c_str(),
           GetTypeName().AsCString("<invalid type>"), strm.GetData());
     return ValueObjectSP();
   }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/optional/TestDataFormatterGenericOptional.py

@@ -88,7 +88,7 @@ def cleanup():
         self.expect(
             "frame variable *number_not_engaged",
             error=True,
-            substrs=["not a pointer or reference type"],
+            substrs=["dereference failed: not a"],
         )
 
     @add_test_categories(["libc++"])