Merge pull request #8498 from adrian-prantl/124540552

Support Objective-C enums without SwiftASTContext

Author: adrian-prantl

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

@@ -16,6 +16,8 @@
 #include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/CompilerType.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "clang/AST/Decl.h"
@@ -87,17 +89,29 @@ void lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
   // standalone and provided with a callback to read the APINote
   // information.
   auto ts = m_type.GetTypeSystem();
+  TypeSystemSwift *tss = nullptr;
   std::shared_ptr<SwiftASTContext> swift_ast_ctx;
   if (auto trts =
           ts.dyn_cast_or_null<TypeSystemSwiftTypeRef>()) {
-    m_type = trts->ReconstructType(m_type, exe_ctx);
-    swift_ast_ctx = m_type.GetTypeSystem().dyn_cast_or_null<SwiftASTContext>();
-    if (!swift_ast_ctx)
-      return;
-    decl_ts = GetAsEnumDecl(m_type);
-    enum_decl = decl_ts.first;
-    if (!enum_decl)
-      return;
+    tss = trts.get();
+    CompilerType ast_type = trts->ReconstructType(m_type, exe_ctx);
+    swift_ast_ctx =
+        ast_type.GetTypeSystem().dyn_cast_or_null<SwiftASTContext>();
+    if (swift_ast_ctx) {
+      auto ast_decl_ts = GetAsEnumDecl(ast_type);
+      if (ast_decl_ts.first) {
+        tss = swift_ast_ctx.get();
+        enum_decl = ast_decl_ts.first;
+        m_type = ast_type;
+      } else {
+        LLDB_LOG(GetLog(LLDBLog::DataFormatters),
+                 "Cannot get Clang type for {0}",
+                 m_type.GetMangledTypeName());
+      }
+    } else {
+      LLDB_LOG(GetLog(LLDBLog::DataFormatters), "Cannot reconstruct {0}",
+               m_type.GetMangledTypeName());
+    }
   }
 
   auto iter = enum_decl->enumerator_begin(), end = enum_decl->enumerator_end();
@@ -112,8 +126,7 @@ void lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
         case_init_val = case_init_val.zext(64);
       if (case_init_val.getBitWidth() > 64)
         continue;
-      ConstString case_name(
-          swift_ast_ctx->GetSwiftName(case_decl, *decl_ts.second));
+      ConstString case_name(tss->GetSwiftName(case_decl, *decl_ts.second));
       m_cases->push_back({case_init_val, case_name});
     }
   }

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

@@ -688,12 +688,32 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
   if (!ts)
     return llvm::make_error<llvm::StringError>("no Swift typesystem",
                                                llvm::inconvertibleErrorCode());
+  if (!type)
+    return llvm::make_error<llvm::StringError>("invalid type",
+                                               llvm::inconvertibleErrorCode());
 
   // Deal with the LLDB-only SILPackType variant.
   if (auto pack_type = ts->IsSILPackType(type))
     if (pack_type->expanded)
       return pack_type->count;
 
+  // Deal with Clang types.
+  {
+    CompilerType clang_type =
+        LookupAnonymousClangType(type.GetMangledTypeName().AsCString());
+    if (!clang_type)
+      ts->IsImportedType(type.GetOpaqueQualType(), &clang_type);
+    if (clang_type) {
+      bool is_signed;
+      if (clang_type.IsEnumerationType(is_signed))
+        return 1;
+      ExecutionContext exe_ctx;
+      if (exe_scope)
+        exe_scope->CalculateExecutionContext(exe_ctx);
+      return clang_type.GetNumChildren(true, exe_scope ? &exe_ctx : nullptr);
+    }
+  }
+
   // Try the static type metadata.
   const swift::reflection::TypeRef *tr = nullptr;
   auto *ti = GetSwiftRuntimeTypeInfo(type, exe_scope, &tr);
@@ -710,14 +730,6 @@ SwiftLanguageRuntimeImpl::GetNumChildren(CompilerType type,
     //
     // However, some imported Clang types (specifically enums) will also produce
     // `BuiltinTypeInfo` instances. These types are not to be handled here.
-    swift::Demangle::Context dem;
-    NodePointer root = SwiftLanguageRuntime::DemangleSymbolAsNode(
-        type.GetMangledTypeName().GetStringRef(), dem);
-    using Kind = Node::Kind;
-    auto *builtin_type = swift_demangle::nodeAtPath(
-        root, {Kind::TypeMangling, Kind::Type, Kind::BuiltinTypeName});
-    if (builtin_type)
-      return 0;
     LLDB_LOG(GetLog(LLDBLog::Types),
              "{0}: unrecognized builtin type info or this is a Clang type "
              "without DWARF debug info",

lldb/test/API/lang/swift/nserror/Makefile renamed to lldb/test/API/lang/swift/clangimporter/nserror/Makefile

@@ -0,0 +1,4 @@
+SWIFT_SOURCES := main.swift
+SWIFT_OBJC_INTEROP := 1
+SWIFTFLAGS_EXTRAS = -Xcc -I$(SRCDIR)
+include Makefile.rules

lldb/test/API/lang/swift/nserror/TestNSError.py renamed to lldb/test/API/lang/swift/clangimporter/nserror/TestNSError.py

@@ -0,0 +1,36 @@
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbtest as lldbtest
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class TestSwiftNSIntegerNSEnum(lldbtest.TestBase):
+    def do_test(self, use_summary):
+        def check(var, output):
+            if use_summary:
+                lldbutil.check_variable(self, var, False, summary='.'+output)
+            else:
+                lldbutil.check_variable(self, var, False, value=output)
+        
+        self.build()
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, "break here", lldb.SBFileSpec("main.swift")
+        )
+        frame = thread.frames[0]
+        self.assertTrue(frame)
+        check(frame.FindVariable('e1'), 'eCase1')
+        check(frame.FindVariable('e2'), 'eCase2')
+
+    @skipUnlessDarwin
+    @swiftTest
+    def test_reflection(self):
+        self.expect("setting set symbols.swift-enable-ast-context false")
+        self.do_test(use_summary=True)
+
+    # Don't run a clangimporter test without ClangImporter.
+    @skipIf(setting=('symbols.use-swift-clangimporter', 'false'))
+    @skipUnlessDarwin
+    @swiftTest
+    def test_swift_ast(self):
+        self.expect("setting set symbols.swift-enable-ast-context true")
+        self.do_test(use_summary=False)

lldb/test/API/lang/swift/nserror/main.swift renamed to lldb/test/API/lang/swift/clangimporter/nserror/main.swift

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, ObjCEnum) {
+  eCase1, eCase2
+};

lldb/test/API/lang/swift/clangimporter/nsinteger_nsenum/Makefile

@@ -0,0 +1,10 @@
+import Foundation
+import Enum
+
+func main(_ e1 : ObjCEnum, _ e2 : ObjCEnum) {
+  print("break here")
+}
+
+let e1 : ObjCEnum = .eCase1
+let e2 : ObjCEnum = .eCase2
+main(e1, e2)

lldb/test/API/lang/swift/clangimporter/nsinteger_nsenum/TestSwiftNSIntegerNSEnum.py

@@ -0,0 +1,4 @@
+module Enum {
+  header "header.h"
+  export *
+}