[lldb] Fix stepping into ObjcC ctor from Swift

When constructing an Objective C object of type `Foo` from Swift, this
sequence of function calls is used:

```
  * frame #0: 0x000000010000147c test.out`-[Foo initWithString:](self=0x00006000023ec000, _cmd="initWithString:", value=@"Bar") -[Foo initWithString:]  at Foo.m:9:21
    frame #1: 0x00000001000012bc test.out`@nonobjc Foo.init(string:) $sSo3FooC6stringABSS_tcfcTO  at <compiler-generated>:0
    frame #2: 0x0000000100001170 test.out`Foo.__allocating_init(string:) $sSo3FooC6stringABSS_tcfC  at Foo.h:0
    frame #3: 0x0000000100000ed8 test.out`work() $s4test4workyyF  at main.swift:5:18
```

Frames 1 and 2 are common with pure Swift classes, and LLDB has a Thread
Plan to go from `Foo.allocating_init` -> `Foo.init`.

In the case of Objcetive C interop, `Foo.init` has no user code, and is
annotated with `@nonobjc`. The debugger needs a plan to go from that
code to the Objective C implementation. This is what this patch attempts
to fix by creating a plan that runs to any symbol matching `Foo init`
(this will match all the :withBlah suffixes).

This seems to be the only possible fix for this. While Objective C
constructors are not necessarily called init, the interop layer seems to
assume this.

The only other alternative has some obstacles that could not be easily
overcome. Here's the main idea for that. The assembly for `@nonobjc
Foo.init` looks like (deleted all non branches):

```
test.out`@nonobjc Foo.init(string:):
...
    0x1000012a0 <+20>: bl     0x100001618    ; symbol stub for: Swift.String._bridgeToObjectiveC() -> __C.NSString
...
    0x1000012b8 <+44>: bl     0x100001630    ; symbol stub for: objc_msgSend
...
    0x1000012e8 <+92>: ret
```

If we had more String arguments, there would be more calls to
`_bridgeToObjectiveC`. The call to `objc_msgSend` is the important one,
and LLDB knows how to go from that to the target of the message, LLDB
has ThreadPlans for that. However, setting a breakpoint on
`objc_msgSend` would fail: the calls to `_bridgeToObjectiveC` may also
call `objc_msgSend`, so LLDB would end up in the wrong `objc_msgSend`.
This is not entirely bad, LLDB would step back to `Foo.init`.

Here's the catch: the language runtime refuses to create other plans if
PC is not at the start of the function, which makes sense, as it would
not be able to distinguish if its job was already done previously or
not, unless it had a stateful plan (which it doesn't today).

Author: felipepiovezan

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;
   }
 }
 
@@ -537,6 +547,25 @@ static lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
           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);
+
+    SymbolContextList sc_list;
+    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
     // and it is possible to go to the AST and get it to replay the

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()

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

@@ -0,0 +1,16 @@
+#include "bridging-header.h"
+
+@implementation ObjcClass
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    self.someString = @"The objc string";
+  }
+  return self;
+}
+
++ (id<ObjcProtocol>)getP {
+  return [ObjcClass new];
+}
+@end