[lldb] Implement SwiftLanguageRuntime::AreFuncletsOfSameAsyncFunction

This is going to be useful for the Swift Language plugin to identify whether two
symbol contexts are equivalent, an operation which is done by thread plans such
as ThreadPlanStepOverRange.

The implementation compares the following attributes of the mangling tree:

* If these funclets come from a simple async function (as opposed to a closure),
we compare the "Function" child node in the tree.

* If these funclets come from an async closure:
** Their "Number" child node must be the same. This number distinguishes
different closures in the same scope.
** The closure type must be the same.
** If they have a parent closure, it must be identical.
** If they have a parent function, it must be identical.

Author: felipepiovezan

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

@@ -132,6 +132,20 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   /// since some day we may want to support more than one swift variant.
   static bool IsSwiftMangledName(llvm::StringRef name);
 
+  enum class FuncletComparisonResult {
+    NotBothFunclets,
+    DifferentAsyncFunctions,
+    SameAsyncFunction
+  };
+
+  /// Compares name1 and name2 to decide whether they are both async funclets.
+  /// If either is not an async funclet, returns NotBothFunclets.
+  /// If they are both funclets but of different async functions, returns
+  /// DifferentAsyncFunctions.
+  /// Otherwise, returns SameAsyncFunction.
+  static FuncletComparisonResult
+  AreFuncletsOfSameAsyncFunction(StringRef name1, StringRef name2);
+
   /// Return true if name is a Swift async function symbol.
   static bool IsSwiftAsyncFunctionSymbol(llvm::StringRef name);
 

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

@@ -105,6 +105,77 @@ static bool IsSwiftAsyncFunctionSymbol(swift::Demangle::NodePointer node) {
                       Node::Kind::AsyncAnnotation});
 }
 
+/// Returns true if closure1 and closure2 have the same number, type, and
+/// parent closures / function.
+static bool AreFuncletsOfSameAsyncClosure(NodePointer closure1,
+                                          NodePointer closure2) {
+  NodePointer closure1_number = childAtPath(closure1, Node::Kind::Number);
+  NodePointer closure2_number = childAtPath(closure2, Node::Kind::Number);
+  if (!Node::deepEquals(closure1_number, closure2_number))
+    return false;
+
+  NodePointer closure1_type = childAtPath(closure1, Node::Kind::Type);
+  NodePointer closure2_type = childAtPath(closure2, Node::Kind::Type);
+  if (!Node::deepEquals(closure1_type, closure2_type))
+    return false;
+
+  // Because the tree is inverted, a parent closure (in swift code) is a child
+  // *node* (in the demangle tree). Check that any such parents are identical.
+  NodePointer closure1_parent =
+      childAtPath(closure1, Node::Kind::ExplicitClosure);
+  NodePointer closure2_parent =
+      childAtPath(closure2, Node::Kind::ExplicitClosure);
+  if (!Node::deepEquals(closure1_parent, closure2_parent))
+    return false;
+
+  // If there are no ExplicitClosure as parents, there may still be a
+  // Function. Also check that they are identical.
+  NodePointer closure1_function = childAtPath(closure1, Node::Kind::Function);
+  NodePointer closure2_function = childAtPath(closure2, Node::Kind::Function);
+  return Node::deepEquals(closure1_function, closure2_function);
+}
+
+SwiftLanguageRuntime::FuncletComparisonResult
+SwiftLanguageRuntime::AreFuncletsOfSameAsyncFunction(StringRef name1,
+                                                     StringRef name2) {
+  using namespace swift::Demangle;
+  Context ctx;
+  NodePointer node1 = DemangleSymbolAsNode(name1, ctx);
+  NodePointer node2 = DemangleSymbolAsNode(name2, ctx);
+
+  if (!IsAnySwiftAsyncFunctionSymbol(node1) ||
+      !IsAnySwiftAsyncFunctionSymbol(node2))
+    return FuncletComparisonResult::NotBothFunclets;
+
+  // Peel off Static nodes.
+  NodePointer static_wrapper1 = childAtPath(node1, Node::Kind::Static);
+  NodePointer static_wrapper2 = childAtPath(node2, Node::Kind::Static);
+  if (static_wrapper1 || static_wrapper2) {
+    if (!static_wrapper1 | !static_wrapper2)
+      return FuncletComparisonResult::DifferentAsyncFunctions;
+    node1 = static_wrapper1;
+    node2 = static_wrapper2;
+  }
+
+  // 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;
+  }
+
+  // Otherwise, find the corresponding function and compare the two.
+  NodePointer function1 = childAtPath(node1, Node::Kind::Function);
+  NodePointer function2 = childAtPath(node2, Node::Kind::Function);
+  return Node::deepEquals(function1, function2)
+             ? FuncletComparisonResult::SameAsyncFunction
+             : FuncletComparisonResult::DifferentAsyncFunctions;
+}
+
 bool SwiftLanguageRuntime::IsSwiftAsyncFunctionSymbol(StringRef name) {
   if (!IsSwiftMangledName(name))
     return false;

lldb/unittests/Symbol/TestSwiftDemangler.cpp

@@ -11,6 +11,39 @@ static constexpr auto IsAnySwiftAsyncFunctionSymbol = [](StringRef name) {
   return SwiftLanguageRuntime::IsAnySwiftAsyncFunctionSymbol(name);
 };
 
+using FuncletComparisonResult = SwiftLanguageRuntime::FuncletComparisonResult;
+static constexpr auto AreFuncletsOfSameAsyncFunction =
+    SwiftLanguageRuntime::AreFuncletsOfSameAsyncFunction;
+
+/// Checks that all names in \c funclets belong to the same function.
+static void CheckGroupOfFuncletsFromSameFunction(ArrayRef<StringRef> funclets) {
+  for (StringRef funclet1 : funclets)
+    for (StringRef funclet2 : funclets) {
+      EXPECT_EQ(FuncletComparisonResult::SameAsyncFunction,
+                AreFuncletsOfSameAsyncFunction(funclet1, funclet2))
+          << funclet1 << " -- " << funclet2;
+      EXPECT_EQ(FuncletComparisonResult::SameAsyncFunction,
+                AreFuncletsOfSameAsyncFunction(funclet2, funclet1))
+          << funclet1 << " -- " << funclet2;
+    }
+}
+
+/// Checks that all pairs of combinations of names from \c funclets1 and \c
+/// funclets2 belong to different functions.
+static void
+CheckGroupOfFuncletsFromDifferentFunctions(ArrayRef<StringRef> funclets1,
+                                           ArrayRef<StringRef> funclets2) {
+  for (StringRef funclet1 : funclets1)
+    for (StringRef funclet2 : funclets2) {
+      EXPECT_EQ(FuncletComparisonResult::DifferentAsyncFunctions,
+                AreFuncletsOfSameAsyncFunction(funclet1, funclet2))
+          << funclet1 << " -- " << funclet2;
+      EXPECT_EQ(FuncletComparisonResult::DifferentAsyncFunctions,
+                AreFuncletsOfSameAsyncFunction(funclet2, funclet1))
+          << funclet1 << " -- " << funclet2;
+    }
+}
+
 TEST(TestSwiftDemangleAsyncNames, BasicAsync) {
   // "sayBasic" == a basic async function
   // "sayGeneric" == a generic async function
@@ -31,6 +64,10 @@ TEST(TestSwiftDemangleAsyncNames, BasicAsync) {
     EXPECT_TRUE(IsSwiftMangledName(async_name)) << async_name;
     EXPECT_TRUE(IsAnySwiftAsyncFunctionSymbol(async_name)) << async_name;
   }
+
+  CheckGroupOfFuncletsFromSameFunction(basic_funclets);
+  CheckGroupOfFuncletsFromSameFunction(generic_funclets);
+  CheckGroupOfFuncletsFromDifferentFunctions(basic_funclets, generic_funclets);
 }
 
 TEST(TestSwiftDemangleAsyncNames, ClosureAsync) {
@@ -69,19 +106,48 @@ TEST(TestSwiftDemangleAsyncNames, ClosureAsync) {
     EXPECT_TRUE(IsSwiftMangledName(async_name)) << async_name;
     EXPECT_TRUE(IsAnySwiftAsyncFunctionSymbol(async_name)) << async_name;
   }
+
+  CheckGroupOfFuncletsFromSameFunction(nested1_funclets);
+  CheckGroupOfFuncletsFromSameFunction(nested2_funclets1);
+  CheckGroupOfFuncletsFromSameFunction(nested2_funclets2);
+  CheckGroupOfFuncletsFromSameFunction(nested2_funclets_top_not_async);
+
+  CheckGroupOfFuncletsFromDifferentFunctions(nested1_funclets,
+                                             nested2_funclets1);
+  CheckGroupOfFuncletsFromDifferentFunctions(nested1_funclets,
+                                             nested2_funclets2);
+  CheckGroupOfFuncletsFromDifferentFunctions(nested1_funclets,
+                                             nested2_funclets_top_not_async);
+  CheckGroupOfFuncletsFromDifferentFunctions(nested2_funclets1,
+                                             nested2_funclets2);
+  CheckGroupOfFuncletsFromDifferentFunctions(nested2_funclets1,
+                                             nested2_funclets_top_not_async);
+  CheckGroupOfFuncletsFromDifferentFunctions(nested2_funclets2,
+                                             nested2_funclets_top_not_async);
 }
 
 TEST(TestSwiftDemangleAsyncNames, StaticAsync) {
   // static async functions
-  SmallVector<StringRef> async_names = {
-      "$s1a6StructV9sayStaticyySSYaFZ"
+  SmallVector<StringRef> static_async_funclets = {
+      "$s1a6StructV9sayStaticyySSYaFZ",
       "$s1a6StructV9sayStaticyySSYaFZTY0_",
       "$s1a6StructV9sayStaticyySSYaFZTQ1_",
       "$s1a6StructV9sayStaticyySSYaFZTY2_",
   };
 
-  for (StringRef async_name : async_names) {
+  for (StringRef async_name : static_async_funclets) {
     EXPECT_TRUE(IsSwiftMangledName(async_name)) << async_name;
     EXPECT_TRUE(IsAnySwiftAsyncFunctionSymbol(async_name)) << async_name;
   }
+
+  CheckGroupOfFuncletsFromSameFunction(static_async_funclets);
+
+  // Make sure we can compare static funclets to other kinds of funclets
+  SmallVector<StringRef> other_funclets = {
+      // Nested funclets:
+      "$s1a8sayHelloyyYaFyypYacfU_", "$s1a8sayHelloyyYaFyypYacfU_TY0_",
+      // "Normal" funclets:
+      "$s1a8sayBasicyySSYaF", "$s1a8sayBasicyySSYaFTY0_"};
+  CheckGroupOfFuncletsFromDifferentFunctions(static_async_funclets,
+                                             other_funclets);
 }