[lldb] Change the representation of Swift enums

(Payload-carrying) Swift enums are a challenging datastructure to
support in LLDB; this patch makes an attempt to clean up a problem
with the previous implementation, namely the dynamic nature of the
children of an enum, which has, in the past, lead to caching bugs when
displaying the children of enums. The new scheme is as follows:

- The static value of an enum is its discriminator (its case).

- An enum has no static children.

- The synthtic value of an enum is its projected case's payload.

- A synthetic child provider for all Swift enums provides synthetic
  children, which are the children of the projected case's payload.

For example:

```
enum E {
  case a
  case b(Int, (Int, Int))
}

let a : E= .a
let b : E= .b(1, (2, 3))
```

The value of `a` is `.a`.
The value of `b` is `.b`.
The synthtic value of `b` is (1, (2, 3)).
The synthetic child 0 of `b` is 1.
The synthetic child 1 of `b` is (2, 3).
The number of (non-synthetic) children of `b` is 0.

The Swift Optional formatter behaves similarly.

Known Issues:

- SwiftRuntimeTypeVisitor does currently not visit the children of
  Objective-C types; this also needs to get fixed, and is surfaced by
  the new synthtic child providers in 1 test.

Implementation Notes:

This removes a lot of enum-handling code from SwiftLanguageRuntime;
simplifying the type visitor and dynamic type resolution, adn moves it
into the Enum/Optional synthetic frontends.

Author: adrian-prantl

lldb/source/Plugins/Language/Swift/SwiftFormatters.cpp

@@ -745,9 +745,9 @@ class EnumSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
-  ExecutionContextRef m_exe_ctx_ref;
-  ConstString m_element_name;
-  size_t m_child_index;
+  ValueObjectSP m_projected;
+  lldb::DynamicValueType m_dynamic = eNoDynamicValues;
+  bool m_indirect = false;
 };
 
 static std::string mangledTypenameForTasksTuple(size_t count) {
@@ -1511,46 +1511,83 @@ class ActorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::EnumSyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_exe_ctx_ref(),
-      m_element_name(nullptr), m_child_index(UINT32_MAX) {
+    : SyntheticChildrenFrontEnd(*valobj_sp.get()) {
   if (valobj_sp)
     Update();
 }
 
 llvm::Expected<uint32_t>
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::CalculateNumChildren() {
-  return m_child_index != UINT32_MAX ? 1 : 0;
+  if (m_indirect && m_projected)
+    return m_projected->GetNumChildren();
+  return m_projected ? 1 : 0;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::GetChildAtIndex(
     uint32_t idx) {
-  if (idx)
-    return ValueObjectSP();
-  if (m_child_index == UINT32_MAX)
-    return ValueObjectSP();
-  return m_backend.GetChildAtIndex(m_child_index, true);
+  ValueObjectSP value_sp;
+  // Hide the indirection.
+  if (m_indirect && m_projected) {
+    value_sp = m_projected->GetChildAtIndex(idx);
+  } else {
+    if (idx != 0)
+      return {};
+    value_sp = m_projected;
+  }
+  if (!value_sp)
+    return {};
+
+  return value_sp;
 }
 
 lldb::ChildCacheState
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::Update() {
-  m_element_name.Clear();
-  m_child_index = UINT32_MAX;
-  m_exe_ctx_ref = m_backend.GetExecutionContextRef();
-  m_element_name.SetCString(m_backend.GetValueAsCString());
-  m_child_index = m_backend.GetIndexOfChildWithName(m_element_name);
+  auto *runtime = SwiftLanguageRuntime::Get(m_backend.GetProcessSP());
+  if (!runtime)
+    return ChildCacheState::eRefetch;
+
+  llvm::Expected<ValueObjectSP> projected =
+      runtime->SwiftLanguageRuntime::ProjectEnum(m_backend);
+  if (!projected) {
+    LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), projected.takeError(),
+                   "{0}");
+    return ChildCacheState::eRefetch;
+  }
+
+  m_dynamic = m_backend.GetDynamicValueType();
+  m_projected = *projected;
+  if (m_projected &&
+      m_projected->GetName().GetStringRef().starts_with("$indirect."))
+    m_indirect = true;
+  else
+    m_indirect = false;
+
+  if (!m_projected)
+    return ChildCacheState::eRefetch;
+
+  if ((m_projected->GetCompilerType().GetTypeInfo() & eTypeIsEnumeration))
+    if (auto synthetic_sp = m_projected->GetSyntheticValue())
+      m_projected = synthetic_sp;
+
+  if (m_dynamic != eNoDynamicValues)
+    if (auto dynamic_sp = m_projected->GetDynamicValue(m_dynamic))
+      m_projected = dynamic_sp;
   return ChildCacheState::eRefetch;
 }
 
 bool lldb_private::formatters::swift::EnumSyntheticFrontEnd::
     MightHaveChildren() {
-  return m_child_index != UINT32_MAX;
+  return m_projected ? true : false;
 }
 
 size_t
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::GetIndexOfChildWithName(
     ConstString name) {
-  if (name == m_element_name)
+  // Hide the indirection.
+  if (m_indirect && m_projected)
+    return m_projected->GetIndexOfChildWithName(name);
+  if (m_projected && name == m_projected->GetName())
     return 0;
   return UINT32_MAX;
 }

lldb/source/Plugins/Language/Swift/SwiftLanguage.cpp

@@ -522,9 +522,9 @@ static void LoadSwiftFormatters(lldb::TypeCategoryImplSP swift_category_sp) {
 
   TypeSummaryImpl::Flags optional_summary_flags;
   optional_summary_flags.SetCascades(true)
-      .SetDontShowChildren(false) // this one will actually be calculated at
-                                  // runtime, what you pass here doesn't matter
-      .SetDontShowValue(true)
+      .SetDontShowChildren(true) // this one will actually be calculated at
+                                 // runtime, what you pass here doesn't matter
+      .SetDontShowValue(false)
       .SetHideItemNames(false)
       .SetShowMembersOneLiner(false)
       .SetSkipPointers(true)
@@ -968,10 +968,6 @@ SwiftLanguage::GetHardcodedSynthetics() {
       CompilerType type(valobj.GetCompilerType());
       Flags type_flags(type.GetTypeInfo());
       if (type_flags.AllSet(eTypeIsSwift | eTypeIsEnumeration)) {
-        // FIXME: The classification of clang-imported enums may
-        // change based on whether a Swift module is present or not.
-        if (!valobj.GetValueAsCString())
-          return nullptr;
         if (!swift_enum_synth)
           swift_enum_synth = lldb::SyntheticChildrenSP(new CXXSyntheticChildren(
               SyntheticChildren::Flags()

lldb/source/Plugins/Language/Swift/SwiftOptionSet.cpp

@@ -199,15 +199,16 @@ bool lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
     }
   }
 
-  if (!any_match)
-    return false;
-
   if (matched_value != value) {
     // Print the unaccounted-for bits separately.
     llvm::APInt residual = value & ~matched_value;
     llvm::SmallString<24> string;
     residual.toString(string, 16, false);
-    ss << ", 0x" << string;
+    if (any_match)
+      ss << ", ";
+    else
+      ss << "rawValue = ";
+    ss << "0x" << string;
   }
   ss << ']';