[lldb][swift] Consider ImplicitClosure nodes when demangling async funclets

These should be peeled off just like ExplicitClosures when considering
async functions. There is another location where they must be handled,
but its test case is encountering another bug in the demangler, so these
will be addressed in a separate commit

Author: felipepiovezan

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

@@ -87,12 +87,14 @@ static bool IsSwiftAsyncFunctionSymbol(swift::Demangle::NodePointer node) {
   if (node->getFirstChild()->getKind() == Node::Kind::Static)
     node = node->getFirstChild();
 
-  // Get the ExplicitClosure or Function node.
+  // Get the {Implicit, Explicit} Closure or Function node.
   // For nested closures in Swift, the demangle tree is inverted: the
-  // inner-most closure is the top-most ExplicitClosure node.
+  // inner-most closure is the top-most closure node.
   NodePointer func_node = [&] {
     if (NodePointer func = childAtPath(node, Node::Kind::Function))
       return func;
+    if (NodePointer implicit = childAtPath(node, Node::Kind::ImplicitClosure))
+      return implicit;
     return childAtPath(node, Node::Kind::ExplicitClosure);
   }();
 
@@ -206,14 +208,17 @@ SwiftLanguageRuntime::AreFuncletsOfSameAsyncFunction(
   }
 
   // If there are closures involved, do the closure-specific comparison.
-  NodePointer closure1 = childAtPath(node1, Node::Kind::ExplicitClosure);
-  NodePointer closure2 = childAtPath(node2, Node::Kind::ExplicitClosure);
-  if (closure1 || closure2) {
-    if (!closure1 || !closure2)
-      return FuncletComparisonResult::DifferentAsyncFunctions;
-    return AreFuncletsOfSameAsyncClosure(closure1, closure2)
-               ? FuncletComparisonResult::SameAsyncFunction
-               : FuncletComparisonResult::DifferentAsyncFunctions;
+  for (auto closure_kind :
+       {Node::Kind::ImplicitClosure, Node::Kind::ExplicitClosure}) {
+    NodePointer closure1 = childAtPath(node1, closure_kind);
+    NodePointer closure2 = childAtPath(node2, closure_kind);
+    if (closure1 || closure2) {
+      if (!closure1 || !closure2)
+        return FuncletComparisonResult::DifferentAsyncFunctions;
+      return AreFuncletsOfSameAsyncClosure(closure1, closure2)
+                 ? FuncletComparisonResult::SameAsyncFunction
+                 : FuncletComparisonResult::DifferentAsyncFunctions;
+    }
   }
 
   // Otherwise, find the corresponding function and compare the two.

lldb/test/API/lang/swift/async_breakpoints/TestSwiftAsyncBreakpoints.py

@@ -24,9 +24,7 @@ def test(self):
         self.assertEquals(breakpoint1.GetNumLocations(), 1)
         self.assertEquals(breakpoint2.GetNumLocations(), 1)
         self.assertEquals(breakpoint3.GetNumLocations(), 1)
-        # FIXME: there should be two breakpoints here, but the "entry" funclet of the
-        # implicit closure is mangled slightly differently. rdar://147035260
-        self.assertEquals(breakpoint4.GetNumLocations(), 3)
+        self.assertEquals(breakpoint4.GetNumLocations(), 2)
         self.assertEquals(breakpoint5.GetNumLocations(), 1)
 
         location11 = breakpoint1.GetLocationAtIndex(0)

lldb/unittests/Symbol/TestSwiftDemangler.cpp

@@ -90,6 +90,7 @@ TEST(TestSwiftDemangleAsyncNames, BasicAsync) {
 // swiftc -g -Onone test.swift -o - -emit-ir -module-name a \
 // | grep "define.*sayHello"
 // func work() async {}
+// func async_int() async -> Int { return 42; }
 // func sayHello() async {
 //   let closure: (Any) async -> () = { _ in
 //     print("hello")
@@ -112,7 +113,11 @@ TEST(TestSwiftDemangleAsyncNames, BasicAsync) {
 //
 //     await inner_closure2(10)
 //     print("hello")
+//     async let x = await async_int();
+//     print(await x);
 //   }
+//   async let x = await async_int();
+//   print(await x);
 //   await closure(10)
 // }
 TEST(TestSwiftDemangleAsyncNames, ClosureAsync) {
@@ -145,11 +150,24 @@ TEST(TestSwiftDemangleAsyncNames, ClosureAsync) {
       "$s1a18myNonAsyncFunctionyyFyyYacfU_SiypYacfU_SSypYacfU0_TQ1_",
       "$s1a18myNonAsyncFunctionyyFyyYacfU_SiypYacfU_SSypYacfU0_TY2_"};
 
+  SmallVector<StringRef> implicit_closure_inside_function = {
+      "$s1a8sayHelloyyYaFSiyYaYbcfu_",
+      "$s1a8sayHelloyyYaFSiyYaYbcfu_TQ0_",
+      "$s1a8sayHelloyyYaFSiyYaYbcfu_TY1_",
+  };
+  SmallVector<StringRef> implicit_closure_inside_explicit_closure = {
+      "$s1a8sayHelloyyYaFyypYacfU_SiyYaYbcfu_",
+      "$s1a8sayHelloyyYaFyypYacfU_SiyYaYbcfu_TQ0_",
+      "$s1a8sayHelloyyYaFyypYacfU_SiyYaYbcfu_TY1_",
+  };
+
   SmallVector<ArrayRef<StringRef>, 0> funclet_groups = {
       nested1_funclets,
       nested2_funclets1,
       nested2_funclets2,
       nested2_funclets_top_not_async,
+      implicit_closure_inside_function,
+      implicit_closure_inside_explicit_closure,
   };
 
   for (ArrayRef<StringRef> funclet_group : funclet_groups)