Reimplement indirect enum handling on top of Reflection (NFC)

Author: adrian-prantl

lldb/source/Plugins/LanguageRuntime/Swift/ReflectionContext.cpp

@@ -127,6 +127,12 @@ class TargetReflectionContext
     return type_info;
   }
 
+  const swift::reflection::TypeInfo *
+  GetTypeInfoFromInstance(lldb::addr_t instance,
+                          swift::remote::TypeInfoProvider *provider) override {
+    return m_reflection_ctx.getInstanceTypeInfo(instance, provider);
+  }
+
   swift::reflection::MemoryReader &GetReader() override {
     return m_reflection_ctx.getReader();
   }
@@ -169,6 +175,17 @@ class TargetReflectionContext
     return false;
   }
 
+  llvm::Optional<int32_t>
+  ProjectEnumValue(swift::remote::RemoteAddress enum_addr,
+                   const swift::reflection::TypeRef *enum_type_ref,
+                   swift::remote::TypeInfoProvider *provider) override {
+    int32_t case_idx;
+    if (m_reflection_ctx.projectEnumValue(enum_addr, enum_type_ref, &case_idx,
+                                          provider))
+      return case_idx;
+    return {};
+  }
+
   llvm::Optional<std::pair<const swift::reflection::TypeRef *,
                            swift::reflection::RemoteAddress>>
   ProjectExistentialAndUnwrapClass(

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -910,9 +910,12 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
   if (!ts)
     return {};
 
+  lldb::addr_t pointer = LLDB_INVALID_ADDRESS;
   ExecutionContext exe_ctx;
-  if (valobj)
+  if (valobj) {
     exe_ctx = valobj->GetExecutionContextRef();
+    pointer = valobj->GetPointerValue();
+  }
 
   // Deal with the LLDB-only SILPackType variant.
   if (auto pack_element_type = ts->GetSILPackElementAtIndex(type, idx)) {
@@ -935,6 +938,12 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
       [&](const swift::reflection::FieldInfo &field,
           llvm::Optional<TypeSystemSwift::TupleElement> tuple,
           bool hide_existentials) -> CompilerType {
+    bool is_indirect_enum =
+        !field.Offset && field.TR &&
+        llvm::isa<swift::reflection::BuiltinTypeRef>(field.TR) &&
+        llvm::isa<swift::reflection::ReferenceTypeInfo>(field.TI) &&
+        llvm::cast<swift::reflection::ReferenceTypeInfo>(field.TI)
+                .getReferenceKind() == swift::reflection::ReferenceKind::Strong;
     child_name = tuple ? tuple->element_name.GetStringRef().str() : field.Name;
     child_byte_size = field.TI.getSize();
     child_byte_offset = field.Offset;
@@ -943,13 +952,36 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
     child_is_base_class = false;
     child_is_deref_of_parent = false;
     language_flags = 0;
+    if (is_indirect_enum)
+      language_flags |= TypeSystemSwift::LanguageFlags::eIsIndirectEnumCase;
     // SwiftASTContext hardcodes the members of protocols as raw
     // pointers. Remote Mirrors reports them as UnknownObject instead.
     if (hide_existentials && ts->IsExistentialType(type.GetOpaqueQualType()))
       return ts->GetRawPointerType();
-    CompilerType result =
-        tuple ? tuple->element_type : GetTypeFromTypeRef(*ts, field.TR);
-    // Bug-for-bug compatibility. See comment in SwiftASTContext::GetBitSize().
+    CompilerType result;
+    if (tuple)
+      result = tuple->element_type;
+    else if (is_indirect_enum) {
+      ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
+      if (!reflection_ctx)
+        return {};
+      // The indirect enum field should point to a closure context.
+      LLDBTypeInfoProvider tip(*this, *ts);
+      lldb::addr_t instance = MaskMaybeBridgedPointer(m_process, pointer);
+      auto *ti = reflection_ctx->GetTypeInfoFromInstance(instance, &tip);
+      if (!ti)
+        return {};
+      auto *rti = llvm::dyn_cast_or_null<swift::reflection::RecordTypeInfo>(ti);
+      if (rti->getFields().size() < 1)
+        return {};
+      auto &field = rti->getFields()[0];
+      auto *type_ref = field.TR;
+      result = GetTypeFromTypeRef(*ts, type_ref);
+      child_byte_offset = field.Offset;
+    } else
+      result = GetTypeFromTypeRef(*ts, field.TR);
+    // Bug-for-bug compatibility. See comment in
+    // SwiftASTContext::GetBitSize().
     if (result.IsFunctionType())
       child_byte_size = ts->GetPointerByteSize();
     return result;
@@ -1001,7 +1033,7 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
         child_is_base_class = false;
         child_is_deref_of_parent = false;
         language_flags = 0;
-          return ts->GetRawPointerType();
+        return ts->GetRawPointerType();
       }
     }
     return get_from_field_info(fields[idx], tuple, true);
@@ -1013,20 +1045,8 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
       // Skip non-payload cases.
       if (!enum_case.TR)
         continue;
-      if (i++ == idx) {
-        auto is_indirect = [](const swift::reflection::FieldInfo &field) {
-          // FIXME: This is by observation. What's the correct condition?
-          if (auto *tr =
-                  llvm::dyn_cast_or_null<swift::reflection::BuiltinTypeRef>(
-                      field.TR))
-            return llvm::StringRef(tr->getMangledName()).equals("Bo");
-          return false;
-        };
-        auto result = get_from_field_info(enum_case, {}, true);
-        if (is_indirect(enum_case))
-          language_flags |= TypeSystemSwift::LanguageFlags::eIsIndirectEnumCase;
-        return result;
-      }
+      if (i++ == idx)
+        return get_from_field_info(enum_case, {}, true);
     }
     LLDB_LOGF(GetLog(LLDBLog::Types), "index %zu is out of bounds (%d)", idx,
               eti->getNumPayloadCases());
@@ -1055,10 +1075,9 @@ CompilerType SwiftLanguageRuntimeImpl::GetChildCompilerTypeAtIndex(
     if (!instance_ts)
       return {};
 
-    // LLDBTypeInfoProvider needs to kept alive until as long as supers gets accessed.
+    // LLDBTypeInfoProvider needs to be kept alive while supers gets accessed.
     llvm::SmallVector<SuperClassType, 2> supers;
     LLDBTypeInfoProvider tip(*this, *instance_ts);
-    lldb::addr_t pointer = valobj->GetPointerValue();
     reflection_ctx->ForEachSuperClassType(
         &tip, pointer, [&](SuperClassType sc) -> bool {
           if (!found_start) {
@@ -1984,62 +2003,38 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_IndirectEnumCase(
     ValueObject &in_value, lldb::DynamicValueType use_dynamic,
     TypeAndOrName &class_type_or_name, Address &address,
     Value::ValueType &value_type) {
-  static ConstString g_offset("offset");
-
-  DataExtractor data;
   Status error;
-  if (!(in_value.GetParent() && in_value.GetParent()->GetData(data, error) &&
-        error.Success()))
-    return false;
-
-  bool has_payload;
-  bool is_indirect;
-  CompilerType payload_type;
-  if (!SwiftASTContext::GetSelectedEnumCase(
-          in_value.GetParent()->GetCompilerType(), data, nullptr, &has_payload,
-          &payload_type, &is_indirect))
-    return false;
+  CompilerType child_type = in_value.GetCompilerType();
+  class_type_or_name.SetCompilerType(child_type);
 
-  if (has_payload && is_indirect && payload_type)
-    class_type_or_name.SetCompilerType(payload_type);
-
-  lldb::addr_t box_addr = in_value.GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+  auto *enum_obj = in_value.GetParent();
+  lldb::addr_t box_addr = enum_obj->GetPointerValue();
   if (box_addr == LLDB_INVALID_ADDRESS)
     return false;
 
-  box_addr = MaskMaybeBridgedPointer(m_process, box_addr);
+  box_addr =
+    MaskMaybeBridgedPointer(m_process, box_addr);
   lldb::addr_t box_location = m_process.ReadPointerFromMemory(box_addr, error);
   if (box_location == LLDB_INVALID_ADDRESS)
     return false;
-
+ 
   box_location = MaskMaybeBridgedPointer(m_process, box_location);
-  ProcessStructReader reader(&m_process, box_location, GetBoxMetadataType());
-  uint32_t offset = reader.GetField<uint32_t>(g_offset);
-  lldb::addr_t box_value = box_addr + offset;
-
-  // try to read one byte at the box value
-  m_process.ReadUnsignedIntegerFromMemory(box_value, 1, 0, error);
-  if (error.Fail()) // and if that fails, then we're off in no man's land
-    return false;
-
-  Flags type_info(payload_type.GetTypeInfo());
+  lldb::addr_t box_value = box_addr + in_value.GetByteOffset();
+  Flags type_info(child_type.GetTypeInfo());
   if (type_info.AllSet(eTypeIsSwift) &&
       type_info.AnySet(eTypeIsClass | eTypeIsProtocol)) {
     ExecutionContext exe_ctx = in_value.GetExecutionContextRef();
     ValueObjectSP valobj_sp = ValueObjectMemory::Create(
-        exe_ctx.GetBestExecutionContextScope(), "_", box_value, payload_type);
+        exe_ctx.GetBestExecutionContextScope(), "_", box_value, child_type);
     if (!valobj_sp)
       return false;
 
-    if (!GetDynamicTypeAndAddress(*valobj_sp, use_dynamic, class_type_or_name,
-                                  address, value_type))
-      return false;
-
-    address.SetRawAddress(box_value);
-    return true;
+    return GetDynamicTypeAndAddress(*valobj_sp, use_dynamic, class_type_or_name,
+                                    address, value_type);
   } else {
     // This is most likely a statically known type.
     address.SetLoadAddress(box_value, &m_process.GetTarget());
+    value_type = Value::GetValueTypeFromAddressType(eAddressTypeLoad);
     return true;
   }
 }

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeImpl.h

@@ -243,6 +243,9 @@ class SwiftLanguageRuntimeImpl {
     virtual const swift::reflection::TypeInfo *
     GetTypeInfo(const swift::reflection::TypeRef *type_ref,
                 swift::remote::TypeInfoProvider *provider) = 0;
+    virtual const swift::reflection::TypeInfo *
+    GetTypeInfoFromInstance(lldb::addr_t instance,
+                            swift::remote::TypeInfoProvider *provider) = 0;
     virtual swift::remote::MemoryReader &GetReader() = 0;
     virtual const swift::reflection::TypeRef *
     LookupSuperclass(const swift::reflection::TypeRef *tr) = 0;
@@ -255,6 +258,10 @@ class SwiftLanguageRuntimeImpl {
     ProjectExistentialAndUnwrapClass(
         swift::remote::RemoteAddress existential_addess,
         const swift::reflection::TypeRef &existential_tr) = 0;
+    virtual llvm::Optional<int32_t>
+    ProjectEnumValue(swift::remote::RemoteAddress enum_addr,
+                     const swift::reflection::TypeRef *enum_type_ref,
+                     swift::remote::TypeInfoProvider *provider) = 0;
     virtual const swift::reflection::TypeRef *
     ReadTypeFromMetadata(lldb::addr_t metadata_address,
                          bool skip_artificial_subclasses = false) = 0;

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -5085,6 +5085,11 @@ bool SwiftASTContext::IsPossibleDynamicType(opaque_compiler_type_t type,
       can_type->isAnyExistentialType())
     return true;
 
+  if (!IsImportedType(type) &&
+      (swift::isa<swift::EnumType>(can_type) ||
+       swift::isa<swift::BoundGenericEnumType>(can_type)))
+    return true;
+
   // Dynamic Self types are resolved inside DoArchetypeBindingForType(),
   // right before the actual archetype binding.
   if (can_type->hasDynamicSelfType())

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h

@@ -801,7 +801,7 @@ class SwiftASTContext : public TypeSystemSwift {
   uint32_t GetNumPointeeChildren(lldb::opaque_compiler_type_t type);
 
   bool IsImportedType(lldb::opaque_compiler_type_t type,
-                      CompilerType *original_type) override;
+                      CompilerType *original_type = nullptr) override;
 
   CompilerType GetReferentType(lldb::opaque_compiler_type_t type) override;
   CompilerType GetStaticSelfType(lldb::opaque_compiler_type_t type) override;

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp

@@ -2223,9 +2223,10 @@ bool TypeSystemSwiftTypeRef::IsPossibleDynamicType(opaque_compiler_type_t type,
       case Node::Kind::ProtocolListWithAnyObject:
       case Node::Kind::ExistentialMetatype:
       case Node::Kind::DynamicSelf:
+      case Node::Kind::Enum:
+      case Node::Kind::BoundGenericEnum:
         return true;
-      case Node::Kind::BoundGenericStructure:
-      case Node::Kind::BoundGenericEnum: {
+      case Node::Kind::BoundGenericStructure: {
         if (node->getNumChildren() < 2)
           return false;
         NodePointer type_list = node->getLastChild();
@@ -3112,7 +3113,7 @@ CompilerType TypeSystemSwiftTypeRef::GetChildCompilerTypeAtIndex(
     assert(Equivalent(child_is_base_class, ast_child_is_base_class));
     assert(Equivalent(child_is_deref_of_parent, ast_child_is_deref_of_parent));
     // There are cases where only the runtime correctly detects an indirect enum.
-    ast_language_flags |= language_flags & LanguageFlags::eIsIndirectEnumCase;
+    ast_language_flags |= (language_flags & LanguageFlags::eIsIndirectEnumCase);
     assert(Equivalent(language_flags, ast_language_flags));
   });
 #endif

lldb/test/API/lang/swift/foundation_value_types/indexpath/main.swift

@@ -16,7 +16,7 @@ func main() {
   var short_path = IndexPath(indexes: [1,2])
   var very_short_path = IndexPath(indexes: [1])
   var empty_path = IndexPath()
-  print("done!") //% self.expect("frame variable path", substrs=['5 indices'])
+  print("done!") //% self.expect("frame variable path -d run", substrs=['5 indices'])
    //% self.expect("frame variable short_path", substrs=['2 indices'])
    //% self.expect("frame variable very_short_path", substrs=['1 index'])   
    //% self.expect("frame variable empty_path", substrs=['0 indices'])

lldb/test/API/lang/swift/variables/indirect_enums/TestIndirectEnumVariables.py

@@ -37,8 +37,6 @@ def test_indirect_enum_variables(self):
 
     def setUp(self):
         TestBase.setUp(self)
-        self.main_source = "main.swift"
-        self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     def get_variable(self, name):
         x = self.frame().FindVariable(name)
@@ -56,13 +54,13 @@ def check_enum(
         child_summary=None,
     ):
         if value:
-            self.assertTrue(
-                enum.GetValue() == value,
+            self.assertEqual(
+                enum.GetValue(), value,
                 "%s.GetValue() == %s" % (enum.GetName(), value),
             )
         if summary:
-            self.assertTrue(
-                enum.GetSummary() == summary,
+            self.assertEqual(
+                enum.GetSummary(), summary,
                 "%s.GetSummary() == %s" % (enum.GetName(), summary),
             )
 
@@ -74,40 +72,23 @@ def check_enum(
                 child.SetPreferSyntheticValue(True)
             self.assertTrue(child.IsValid(), "child at path %s valid" % (child_path))
             if child_value:
-                self.assertTrue(
-                    child.GetValue() == child_value,
+                self.assertEqual(
+                    child.GetValue(), child_value,
                     "%s.GetValue() == %s" % (child.GetName(), child_value),
                 )
             if child_summary:
-                self.assertTrue(
-                    child.GetSummary() == child_summary,
+                self.assertEqual(
+                    child.GetSummary(), child_summary,
                     "%s.GetSummary() == %s" % (child.GetName(), child_summary),
                 )
 
     def do_test(self, break_pattern):
         """Tests that indirect Enum variables display correctly"""
-        exe_name = "a.out"
-        exe = self.getBuildArtifact(exe_name)
-
-        # Create the target
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
-        # Set the breakpoints
-        breakpoint = target.BreakpointCreateBySourceRegex(
-            break_pattern, self.main_source_spec
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self,
+            break_pattern,
+            lldb.SBFileSpec("main.swift"),
         )
-        self.assertTrue(breakpoint.GetNumLocations() > 0, VALID_BREAKPOINT)
-
-        # Launch the process, and do not stop at the entry point.
-        process = target.LaunchSimple(None, None, os.getcwd())
-
-        self.assertTrue(process, PROCESS_IS_VALID)
-
-        # Frame #0 should be at our breakpoint.
-        threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint)
-
-        self.assertTrue(len(threads) == 1)
 
         GP_StructType = self.get_variable("GP_StructType")
         GP_TupleType = self.get_variable("GP_TupleType")