[lldb] Introduce Swift Task synthetic provider (swiftlang#9404)

Add a synthetic provider for Swift's `Task` and `UnsafeCurrentTask` types.

This uses `ReflectionContext::asyncTaskInfo`. In this initial version, only the bool 
flags are plugged through. Follow up changes will add more metadata (ex task ID, 
priority), child tasks, and backtraces.

Author: kastiglione

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

@@ -12,6 +12,7 @@
 
 #include "SwiftFormatters.h"
 #include "Plugins/Language/Swift/SwiftStringIndex.h"
+#include "Plugins/LanguageRuntime/Swift/ReflectionContextInterface.h"
 #include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/ValueObject.h"
@@ -20,12 +21,17 @@
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-enumerations.h"
 #include "swift/AST/Types.h"
 #include "swift/Demangling/ManglingMacros.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/FormatAdapters.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 // FIXME: we should not need this
@@ -721,6 +727,7 @@ bool lldb_private::formatters::swift::BuiltinObjC_SummaryProvider(
 namespace lldb_private {
 namespace formatters {
 namespace swift {
+
 class EnumSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   EnumSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
@@ -736,6 +743,112 @@ class EnumSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
   ConstString m_element_name;
   size_t m_child_index;
 };
+
+/// Synthetic provider for `Swift.Task`.
+///
+/// As seen by lldb, a `Task` instance is an opaque pointer, with neither type
+/// metadata nor an AST to describe it. To implement this synthetic provider, a
+/// `Task`'s state is retrieved from a `ReflectionContext`, and that data is
+/// used to manually construct `ValueObject` children.
+class TaskSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  TaskSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+      : SyntheticChildrenFrontEnd(*valobj_sp.get()) {}
+
+  constexpr static StringLiteral TaskChildren[] = {
+      "isChildTask",    "isFuture",    "isGroupChildTask",
+      "isAsyncLetTask", "isCancelled", "isStatusRecordLocked",
+      "isEscalated",    "isEnqueued",  "isRunning",
+  };
+
+  llvm::Expected<uint32_t> CalculateNumChildren() override {
+    auto count = ArrayRef(TaskChildren).size();
+    return m_task_info.hasIsRunning ? count : count - 1;
+  }
+
+  lldb::ValueObjectSP GetChildAtIndex(uint32_t idx) override {
+    auto target_sp = m_backend.GetTargetSP();
+#define RETURN_CHILD(FIELD, NAME)                                              \
+  if (!FIELD)                                                                  \
+    FIELD = ValueObject::CreateValueObjectFromBool(target_sp,                  \
+                                                   m_task_info.NAME, #NAME);   \
+  return FIELD
+
+    switch (idx) {
+    case 0:
+      RETURN_CHILD(m_is_child_task_sp, isChildTask);
+    case 1:
+      RETURN_CHILD(m_is_future_sp, isFuture);
+    case 2:
+      RETURN_CHILD(m_is_group_child_task_sp, isGroupChildTask);
+    case 3:
+      RETURN_CHILD(m_is_async_let_task_sp, isAsyncLetTask);
+    case 4:
+      RETURN_CHILD(m_is_cancelled_sp, isCancelled);
+    case 5:
+      RETURN_CHILD(m_is_status_record_locked_sp, isStatusRecordLocked);
+    case 6:
+      RETURN_CHILD(m_is_escalated_sp, isEscalated);
+    case 7:
+      RETURN_CHILD(m_is_enqueued_sp, isEnqueued);
+    case 8:
+      RETURN_CHILD(m_is_running_sp, isRunning);
+    default:
+      return {};
+    }
+
+#undef RETURN_CHILD
+  }
+
+  lldb::ChildCacheState Update() override {
+    if (auto *runtime = SwiftLanguageRuntime::Get(m_backend.GetProcessSP())) {
+      ThreadSafeReflectionContext reflection_ctx =
+          runtime->GetReflectionContext();
+      ValueObjectSP task_obj_sp = m_backend.GetChildMemberWithName("_task");
+      uint64_t task_ptr = task_obj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+      if (task_ptr != LLDB_INVALID_ADDRESS) {
+        llvm::Expected<ReflectionContextInterface::AsyncTaskInfo> task_info =
+            reflection_ctx->asyncTaskInfo(task_ptr);
+        if (auto err = task_info.takeError()) {
+          LLDB_LOG(GetLog(LLDBLog::DataFormatters | LLDBLog::Types),
+                   "could not get info for async task {0:x}: {1}", task_ptr,
+                   fmt_consume(std::move(err)));
+        } else {
+          m_task_info = *task_info;
+          for (auto child :
+               {m_is_child_task_sp, m_is_future_sp, m_is_group_child_task_sp,
+                m_is_async_let_task_sp, m_is_cancelled_sp,
+                m_is_status_record_locked_sp, m_is_escalated_sp,
+                m_is_enqueued_sp, m_is_running_sp})
+            child.reset();
+        }
+      }
+    }
+    return ChildCacheState::eRefetch;
+  }
+
+  bool MightHaveChildren() override { return true; }
+
+  size_t GetIndexOfChildWithName(ConstString name) override {
+    ArrayRef children = TaskChildren;
+    auto it = llvm::find(children, name);
+    if (it == children.end())
+      return UINT32_MAX;
+    return std::distance(children.begin(), it);
+  }
+
+private:
+  ReflectionContextInterface::AsyncTaskInfo m_task_info;
+  ValueObjectSP m_is_child_task_sp;
+  ValueObjectSP m_is_future_sp;
+  ValueObjectSP m_is_group_child_task_sp;
+  ValueObjectSP m_is_async_let_task_sp;
+  ValueObjectSP m_is_cancelled_sp;
+  ValueObjectSP m_is_status_record_locked_sp;
+  ValueObjectSP m_is_escalated_sp;
+  ValueObjectSP m_is_enqueued_sp;
+  ValueObjectSP m_is_running_sp;
+};
 }
 }
 }
@@ -794,6 +907,14 @@ lldb_private::formatters::swift::EnumSyntheticFrontEndCreator(
   return (new EnumSyntheticFrontEnd(valobj_sp));
 }
 
+SyntheticChildrenFrontEnd *
+lldb_private::formatters::swift::TaskSyntheticFrontEndCreator(
+    CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
+  if (!valobj_sp)
+    return NULL;
+  return new TaskSyntheticFrontEnd(valobj_sp);
+}
+
 bool lldb_private::formatters::swift::ObjC_Selector_SummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   LLDB_SCOPED_TIMER();

lldb/source/Plugins/Language/Swift/SwiftFormatters.h

@@ -116,6 +116,9 @@ bool TypePreservingNSNumber_SummaryProvider(ValueObject &valobj, Stream &stream,
 
 SyntheticChildrenFrontEnd *EnumSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                                         lldb::ValueObjectSP);
+
+SyntheticChildrenFrontEnd *TaskSyntheticFrontEndCreator(CXXSyntheticChildren *,
+                                                        lldb::ValueObjectSP);
 }
 }
 }

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

@@ -408,7 +408,14 @@ static void LoadSwiftFormatters(lldb::TypeCategoryImplSP swift_category_sp) {
   SetConfig::Get().RegisterSyntheticChildrenCreators(swift_category_sp,
                                                      synth_flags);
 
-  synth_flags.SetSkipPointers(true);
+  AddCXXSynthetic(swift_category_sp,
+                  lldb_private::formatters::swift::TaskSyntheticFrontEndCreator,
+                  "Swift.Task synthetic children",
+                  ConstString("^Swift\\.Task<.+,.+>"), synth_flags, true);
+  AddCXXSynthetic(swift_category_sp,
+                  lldb_private::formatters::swift::TaskSyntheticFrontEndCreator,
+                  "Swift.UnsafeCurrentTask synthetic children",
+                  ConstString("Swift.UnsafeCurrentTask"), synth_flags);
 
   AddCXXSummary(
       swift_category_sp, lldb_private::formatters::swift::Bool_SummaryProvider,

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

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/RemoteInspection/ReflectionContext.h"
 #include "ReflectionContextInterface.h"
 #include "SwiftLanguageRuntimeImpl.h"
 #include "lldb/Utility/LLDBLog.h"
@@ -368,6 +369,28 @@ class TargetReflectionContext : public ReflectionContextInterface {
     return m_reflection_ctx.stripSignedPointer(pointer);
   }
 
+  llvm::Expected<AsyncTaskInfo>
+  asyncTaskInfo(lldb::addr_t AsyncTaskPtr, unsigned ChildTaskLimit,
+                unsigned AsyncBacktraceLimit) override {
+    auto [error, task_info] = m_reflection_ctx.asyncTaskInfo(
+        AsyncTaskPtr, ChildTaskLimit, AsyncBacktraceLimit);
+    if (error)
+      return llvm::createStringError(*error);
+
+    AsyncTaskInfo result;
+    result.isChildTask = task_info.IsChildTask;
+    result.isFuture = task_info.IsFuture;
+    result.isGroupChildTask = task_info.IsGroupChildTask;
+    result.isAsyncLetTask = task_info.IsAsyncLetTask;
+    result.isCancelled = task_info.IsCancelled;
+    result.isStatusRecordLocked = task_info.IsStatusRecordLocked;
+    result.isEscalated = task_info.IsEscalated;
+    result.hasIsRunning = task_info.HasIsRunning;
+    result.isRunning = task_info.IsRunning;
+    result.isEnqueued = task_info.IsEnqueued;
+    return result;
+  }
+
 private:
   /// Return a description of the layout of the record (classes, structs and
   /// tuples) type given its typeref.

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

@@ -18,6 +18,7 @@
 #include "lldb/lldb-types.h"
 #include "swift/ABI/ObjectFile.h"
 #include "swift/Remote/RemoteAddress.h"
+#include "swift/RemoteInspection/ReflectionContext.h"
 #include "swift/RemoteInspection/TypeRef.h"
 #include <optional>
 #include "llvm/ADT/STLFunctionalExtras.h"
@@ -145,6 +146,23 @@ class ReflectionContextInterface {
       swift::reflection::DescriptorFinder *descriptor_finder) = 0;
   virtual swift::remote::RemoteAbsolutePointer
   StripSignedPointer(swift::remote::RemoteAbsolutePointer pointer) = 0;
+  struct AsyncTaskInfo {
+    bool isChildTask = false;
+    bool isFuture = false;
+    bool isGroupChildTask = false;
+    bool isAsyncLetTask = false;
+    bool isCancelled = false;
+    bool isStatusRecordLocked = false;
+    bool isEscalated = false;
+    /// If false, the IsRunning flag is not valid.
+    bool hasIsRunning = false;
+    bool isRunning = false;
+    bool isEnqueued = false;
+  };
+  // The default limits are copied from swift-inspect.
+  virtual llvm::Expected<AsyncTaskInfo>
+  asyncTaskInfo(lldb::addr_t AsyncTaskPtr, unsigned ChildTaskLimit = 1000000,
+                unsigned AsyncBacktraceLimit = 1000) = 0;
 };
 
 using ThreadSafeReflectionContext = LockGuarded<ReflectionContextInterface>;

lldb/test/API/lang/swift/async/formatters/task/Makefile

@@ -0,0 +1,3 @@
+SWIFT_SOURCES := main.swift
+SWIFTFLAGS_EXTRAS := -parse-as-library
+include Makefile.rules

lldb/test/API/lang/swift/async/formatters/task/TestSwiftTaskSyntheticProvider.py

@@ -0,0 +1,47 @@
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+
+    def test_top_level_task(self):
+        """Test Task synthetic child provider for top-level Task."""
+        self.build()
+        lldbutil.run_to_source_breakpoint(
+            self, "break for top-level task", lldb.SBFileSpec("main.swift")
+        )
+        # Note: The value of isEnqueued is timing dependent. For that reason,
+        # the test checks only that it has a value, not what the value is.
+        self.expect(
+            "frame var task",
+            substrs=[
+                "(Task<(), Error>) task = {",
+                "isChildTask = false",
+                "isFuture = true",
+                "isGroupChildTask = false",
+                "isAsyncLetTask = false",
+                "isCancelled = false",
+                "isEnqueued = ",
+            ],
+        )
+
+    def test_current_task(self):
+        """Test Task synthetic child for UnsafeCurrentTask (from an async let)."""
+        self.build()
+        lldbutil.run_to_source_breakpoint(
+            self, "break for current task", lldb.SBFileSpec("main.swift")
+        )
+        self.expect(
+            "frame var currentTask",
+            substrs=[
+                "(UnsafeCurrentTask) currentTask = {",
+                "isChildTask = true",
+                "isFuture = true",
+                "isGroupChildTask = false",
+                "isAsyncLetTask = true",
+                "isCancelled = false",
+                "isEnqueued = false",
+            ],
+        )

lldb/test/API/lang/swift/async/formatters/task/main.swift

@@ -0,0 +1,22 @@
+func f() async -> Int {
+    withUnsafeCurrentTask { currentTask in
+        if let currentTask {
+            print("break for current task")
+        }
+    }
+    return 30
+}
+
+@main struct Main {
+    static func main() async {
+        let task = Task {
+            // Extend the task's lifetime, hopefully long enough for the breakpoint to hit.
+            try await Task.sleep(for: .seconds(0.5))
+            print("inside")
+        }
+        print("break for top-level task")
+
+        async let number = f()
+        print(await number)
+    }
+}