Revert r268591

"Allow LanguageRuntimes to return an error if they fail in the course of dynamic type discovery

This is not meant to report that a value doesn't have a dynamic type - it is only meant as a mechanism to propagate actual type discovery issues (e.g. malformed type metadata for languages that have such a notion)

This information is used by ValueObjectDynamic to set its own m_error, which is a fairly sharp and heavyweight tool to begin with

For the time being, this is an architectural improvement but a practical no-op as no existing runtimes are actually setting errors"

I need to think about what I want to do in this space more carefully - this attempt might be too heavy of a hammer for the nail I am trying to fix, and I don't want to leave it in while I ponder

llvm-svn: 268686

1 files changed, 11 insertions, 37 deletions

diff --git a/lldb/source/Core/ValueObjectDynamicValue.cpp b/lldb/source/Core/ValueObjectDynamicValue.cpp
index 3a34fdf3a86..0ac86a68f19 100644
--- a/lldb/source/Core/ValueObjectDynamicValue.cpp
+++ b/lldb/source/Core/ValueObjectDynamicValue.cpp
@@ -187,41 +187,23 @@ ValueObjectDynamicValue::UpdateValue ()
     LanguageRuntime *runtime = nullptr;
 
     lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage();
-    
-    Error dynamic_type_discovery_error;
-    
     if (known_type != lldb::eLanguageTypeUnknown && known_type != lldb::eLanguageTypeC)
     {
         runtime = process->GetLanguageRuntime (known_type);
         if (runtime)
-            found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent,
-                                                                    m_use_dynamic,
-                                                                    class_type_or_name,
-                                                                    dynamic_address,
-                                                                    value_type,
-                                                                    dynamic_type_discovery_error);
+            found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address, value_type);
     }
     else
     {
         runtime = process->GetLanguageRuntime (lldb::eLanguageTypeC_plus_plus);
         if (runtime)
-            found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent,
-                                                                    m_use_dynamic,
-                                                                    class_type_or_name,
-                                                                    dynamic_address,
-                                                                    value_type,
-                                                                    dynamic_type_discovery_error);
+            found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address, value_type);
 
         if (!found_dynamic_type)
         {
             runtime = process->GetLanguageRuntime (lldb::eLanguageTypeObjC);
             if (runtime)
-                found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent,
-                                                                        m_use_dynamic,
-                                                                        class_type_or_name,
-                                                                        dynamic_address,
-                                                                        value_type,
-                                                                        dynamic_type_discovery_error);
+                found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address, value_type);
         }
     }
 
@@ -247,24 +229,16 @@ ValueObjectDynamicValue::UpdateValue ()
         m_type_impl.Clear();
     }
 
-    // If we don't have a dynamic type...
+    // If we don't have a dynamic type, then make ourselves just a echo of our parent.
+    // Or we could return false, and make ourselves an echo of our parent?
     if (!found_dynamic_type)
     {
-        // ...and it's not because of an error, let's make ourselves an echo of our parent
-        if (dynamic_type_discovery_error.Success())
-        {
-            if (m_dynamic_type_info)
-                SetValueDidChange(true);
-            ClearDynamicTypeInformation();
-            m_dynamic_type_info.Clear();
-            m_value = m_parent->GetValue();
-            m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
-        }
-        else
-        {
-            // ...but if it is because of an error, let's report that to the user
-            m_error = dynamic_type_discovery_error;
-        }
+        if (m_dynamic_type_info)
+            SetValueDidChange(true);
+        ClearDynamicTypeInformation();
+        m_dynamic_type_info.Clear();
+        m_value = m_parent->GetValue();
+        m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get());
         return m_error.Success();
     }