[lldb] Fix stepping into Objective-C interop ctors

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

@@ -45,6 +45,7 @@ enum class ThunkKind {
   AllocatingInit,
   PartialApply,
   ObjCAttribute,
+  NonObjCAttributeOnCtor,
   Reabstraction,
   ProtocolConformance,
 };
@@ -55,6 +56,7 @@ enum class ThunkAction {
   StepIntoConformance,
   StepIntoAllocatingInit,
   StepThrough,
+  RunToObjcCInteropCtor,
 };
 
 } // namespace
@@ -313,6 +315,10 @@ static ThunkKind GetThunkKind(Symbol *symbol) {
   switch (main_node->getKind()) {
   case Node::Kind::ObjCAttribute:
     return ThunkKind::ObjCAttribute;
+  case Node::Kind::NonObjCAttribute:
+    if (hasChild(nodes, Node::Kind::Constructor))
+      return ThunkKind::NonObjCAttributeOnCtor;
+    break;
   case Node::Kind::ProtocolWitness:
     if (hasChild(main_node, Node::Kind::ProtocolConformance))
       return ThunkKind::ProtocolConformance;
@@ -342,6 +348,8 @@ static const char *GetThunkKindName(ThunkKind kind) {
     return "GetThunkTarget";
   case ThunkKind::ObjCAttribute:
     return "GetThunkTarget";
+  case ThunkKind::NonObjCAttributeOnCtor:
+    return "RunToObjcCInteropCtor";
   case ThunkKind::Reabstraction:
     return "GetThunkTarget";
   case ThunkKind::ProtocolConformance:
@@ -363,6 +371,8 @@ static ThunkAction GetThunkAction(ThunkKind kind) {
     return ThunkAction::StepThrough;
   case ThunkKind::ProtocolConformance:
     return ThunkAction::StepIntoConformance;
+  case ThunkKind::NonObjCAttributeOnCtor:
+    return ThunkAction::RunToObjcCInteropCtor;
   }
 }
 
@@ -419,6 +429,66 @@ CreateRunThroughTaskSwitchingTrampolines(Thread &thread,
   return nullptr;
 }
 
+// Search all modules for `target_func` and creates a RunToAddress plan if a
+// single function is found.
+static ThreadPlanSP CreateRunToAddressPlan(StringRef target_func,
+                                           Thread &thread, bool stop_others) {
+  ModuleList modules = thread.GetProcess()->GetTarget().GetImages();
+  SymbolContextList sc_list;
+  modules.FindFunctionSymbols(ConstString(target_func), eFunctionNameTypeFull,
+                              sc_list);
+  if (sc_list.GetSize() != 1 || sc_list[0].symbol == nullptr)
+    return nullptr;
+  Symbol &thunk_symbol = *sc_list[0].symbol;
+  Address target_address = thunk_symbol.GetAddress();
+  if (target_address.IsValid())
+    return std::make_shared<ThreadPlanRunToAddress>(thread, target_address,
+                                                    stop_others);
+  return nullptr;
+}
+
+/// Demangle `symbol_name` and extracts the text at the node described by
+/// `node_path`, if it exists.
+static std::optional<std::string>
+FindClassName(StringRef symbol_name, llvm::ArrayRef<Node::Kind> node_path) {
+  swift::Demangle::Context ctx;
+  NodePointer demangled_node =
+      SwiftLanguageRuntime::DemangleSymbolAsNode(symbol_name, ctx);
+
+  NodePointer class_node = childAtPath(demangled_node, node_path);
+  if (!class_node || !class_node->hasText()) {
+    std::string node_str = getNodeTreeAsString(demangled_node);
+    LLDB_LOGF(GetLog(LLDBLog::Step),
+              "SwiftLanguageRuntime: failed to extract name from "
+              "demangle node: %s",
+              node_str.c_str());
+    return {};
+  }
+  return class_node->getText().str();
+}
+
+/// If sc_list is non-empty, returns a plan that runs to any of its addresses.
+/// Otherwise, returns nullptr.
+static ThreadPlanSP CreateThreadPlanRunToAnySc(Thread &thread,
+                                               SymbolContextList &sc_list,
+                                               bool stop_others) {
+  std::vector<addr_t> load_addresses;
+  Target &target = thread.GetProcess()->GetTarget();
+  for (const SymbolContext &ctor_sc : sc_list) {
+    const Symbol *ctor_symbol = ctor_sc.symbol;
+    if (ctor_symbol)
+      load_addresses.push_back(ctor_symbol->GetLoadAddress(&target));
+  }
+
+  if (load_addresses.empty()) {
+    LLDB_LOG(GetLog(LLDBLog::Step),
+             "SwiftLanguageRuntime: empty sc_list found.");
+    return nullptr;
+  }
+  return std::make_shared<ThreadPlanRunToAddress>(thread, load_addresses,
+                                                  stop_others);
+}
+
 static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                        bool stop_others) {
   // Here are the trampolines we have at present.
@@ -475,19 +545,26 @@ static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
       log->Printf(
           "Stepped to thunk \"%s\" (kind: %s) stepping to target: \"%s\".",
           symbol_name, GetThunkKindName(thunk_kind), thunk_target.c_str());
+    return CreateRunToAddressPlan(thunk_target, thread, stop_others);
+  }
+  case ThunkAction::RunToObjcCInteropCtor: {
+    LLDB_LOG(log, "SwiftLanguageRuntime: running to "
+                  "objective C constructor from swift.");
+    static constexpr auto class_path = {
+        Node::Kind::Constructor, Node::Kind::Class, Node::Kind::Identifier};
+    std::optional<std::string> class_name = FindClassName(symbol_name, class_path);
+    if (!class_name)
+      return nullptr;
+    std::string ctor_name = llvm::formatv("{0} init", *class_name);
 
-    ModuleList modules = thread.GetProcess()->GetTarget().GetImages();
     SymbolContextList sc_list;
-    modules.FindFunctionSymbols(ConstString(thunk_target),
-                                eFunctionNameTypeFull, sc_list);
-    if (sc_list.GetSize() == 1 && sc_list[0].symbol) {
-      Symbol &thunk_symbol = *sc_list[0].symbol;
-      Address target_address = thunk_symbol.GetAddress();
-      if (target_address.IsValid())
-        return std::make_shared<ThreadPlanRunToAddress>(thread, target_address,
-                                                        stop_others);
-    }
-    return nullptr;
+    ModuleFunctionSearchOptions options{/*include_symbols*/ true,
+                                        /*include_inlines*/ true};
+    ModuleList modules = thread.GetProcess()->GetTarget().GetImages();
+    modules.FindFunctions(RegularExpression(ctor_name), options, sc_list);
+
+    ThreadPlanSP plan = CreateThreadPlanRunToAnySc(thread, sc_list, stop_others);
+    return plan;
   }
   case ThunkAction::StepIntoConformance: {
     // The TTW symbols encode the protocol conformance requirements
@@ -582,37 +659,20 @@ static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
   }
   case ThunkAction::StepIntoAllocatingInit: {
     LLDB_LOGF(log, "Stepping into allocating init: \"%s\"", symbol_name);
-    swift::Demangle::Context ctx;
-    NodePointer demangled_node =
-        SwiftLanguageRuntime::DemangleSymbolAsNode(symbol_name, ctx);
-
     using Kind = Node::Kind;
-    NodePointer class_node = childAtPath(
-        demangled_node, {Kind::Allocator, Kind::Class, Kind::Identifier});
-    if (!class_node || !class_node->hasText()) {
-      std::string node_str = getNodeTreeAsString(demangled_node);
-      LLDB_LOGF(log,
-                "Failed to extract constructor name from demangle node: %s",
-                node_str.c_str());
+    static constexpr auto class_path = {Kind::Allocator, Kind::Class,
+                                        Kind::Identifier};
+    std::optional<std::string> class_name =
+        FindClassName(symbol_name, class_path);
+    if (!class_name)
       return nullptr;
-    }
 
     ModuleFunctionSearchOptions options{/*include_symbols*/ true,
                                         /*include_inlines*/ true};
-    std::string ctor_name = llvm::formatv("{0}.init", class_node->getText());
+    std::string ctor_name = llvm::formatv("{0}.init", *class_name);
     SymbolContextList sc_list;
     sc.module_sp->FindFunctions(RegularExpression(ctor_name), options, sc_list);
-    std::vector<addr_t> load_addresses;
-    Target &target = thread.GetProcess()->GetTarget();
-    for (const SymbolContext &ctor_sc : sc_list) {
-      const Symbol *ctor_symbol = ctor_sc.symbol;
-      if (ctor_symbol)
-        load_addresses.push_back(ctor_symbol->GetLoadAddress(&target));
-    }
-    if (load_addresses.empty())
-      return nullptr;
-    return std::make_shared<ThreadPlanRunToAddress>(thread, load_addresses,
-                                                    stop_others);
+    return CreateThreadPlanRunToAnySc(thread, sc_list, stop_others);
   }
   case ThunkAction::StepThrough: {
     if (log)

lldb/test/API/lang/swift/step_into_objc_interop_init/Foo.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+
+@interface Foo : NSObject
+
+@property (nonnull) NSArray<NSString *> *values;
+
+- (nonnull id)init;
+- (nonnull id)initWithString:(nonnull NSString *)value;
+- (nonnull id)initWithString:(nonnull NSString *)value andOtherString:(nonnull NSString *) otherValue;
+
+@end

lldb/test/API/lang/swift/step_into_objc_interop_init/Foo.m

@@ -0,0 +1,18 @@
+#import "Foo.h"
+
+@implementation Foo
+
+- (id)init {
+}
+
+- (id)initWithString:(nonnull NSString *)value {
+  self->_values = @[value];
+  return self;
+}
+
+- (nonnull id)initWithString:(nonnull NSString *)value andOtherString:(nonnull NSString *) otherValue {
+  self->_values = @[value, otherValue];
+  return self;
+}
+
+@end

lldb/test/API/lang/swift/step_into_objc_interop_init/Makefile

@@ -0,0 +1,6 @@
+SWIFT_SOURCES := main.swift
+SWIFT_BRIDGING_HEADER := bridging-header.h
+OBJC_SOURCES := Foo.m
+SWIFT_OBJC_INTEROP := 1
+
+include Makefile.rules

lldb/test/API/lang/swift/step_into_objc_interop_init/TestStepIntoObjCInteropInit.py

@@ -0,0 +1,39 @@
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class TestSwiftObjcProtocol(TestBase):
+    @skipUnlessDarwin
+    @swiftTest
+    def test(self):
+        self.build()
+        (target, process, thread, breakpoint) = lldbutil.run_to_source_breakpoint(
+            self, "break here", lldb.SBFileSpec("main.swift")
+        )
+
+        # Go to the first constructor, assert we can step into it.
+        thread.StepInto()
+        self.assertEqual(thread.stop_reason, lldb.eStopReasonPlanComplete)
+        self.assertIn("-[Foo init]", thread.frames[0].GetFunctionName())
+
+        # Go back to "work" function
+        thread.StepOut()
+        self.assertEqual(thread.stop_reason, lldb.eStopReasonPlanComplete)
+        self.assertIn("work", thread.frames[0].GetFunctionName())
+
+        # Go to the next constructor call.
+        thread.StepOver()
+        self.assertEqual(thread.stop_reason, lldb.eStopReasonPlanComplete)
+        self.assertIn("work", thread.frames[0].GetFunctionName())
+
+        # Assert we can step into it.
+        thread.StepInto()
+        self.assertEqual(thread.stop_reason, lldb.eStopReasonPlanComplete)
+        self.assertIn("-[Foo initWithString:]", thread.frames[0].GetFunctionName())
+
+        # Go back to "work" function
+        thread.StepOut()
+        self.assertEqual(thread.stop_reason, lldb.eStopReasonPlanComplete)
+        self.assertIn("work", thread.frames[0].GetFunctionName())

lldb/test/API/lang/swift/step_into_objc_interop_init/bridging-header.h

@@ -0,0 +1 @@
+#import "Foo.h"

lldb/test/API/lang/swift/step_into_objc_interop_init/main.swift

@@ -0,0 +1,7 @@
+func work() {
+  let noParams = Foo() // break here
+  let oneParam = Foo(string: "Bar")
+  print("done")
+}
+
+work()