[lldb][swift] Add support for stepping async let statements

The use of `async let` in swift introduces two new trampolines that may
trigger a task switch:
1. `swift_asyncLet_get`, which gets called upon `await`ing an `async
   let` variable.
2. `swift_asyncLet_finish`, which gets called when the `async let`
   variable goes out of scope.

We need step through plans for both of those.

Author: felipepiovezan

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

@@ -406,7 +406,19 @@ CreateRunThroughTaskSwitchingTrampolines(Thread &thread,
   if (trampoline_name == "swift_task_switch")
     return CreateRunThroughTaskSwitchThreadPlan(thread,
                                                 LLDB_REGNUM_GENERIC_ARG1);
-
+  // The signature for `swift_asyncLet_get` and `swift_asyncLet_finish` are the
+  // same. Like `task_switch`, the async context (first argument) uses the async
+  // context register, and not the arg1 register; as such, the continuation
+  // funclet can be found in arg3.
+  //
+  // swift_asyncLet_get(SWIFT_ASYNC_CONTEXT AsyncContext *,
+  //                         AsyncLet *,
+  //                         void *,
+  //                         TaskContinuationFunction *,
+  if (trampoline_name == "swift_asyncLet_get" ||
+      trampoline_name == "swift_asyncLet_finish")
+    return CreateRunThroughTaskSwitchThreadPlan(thread,
+                                                LLDB_REGNUM_GENERIC_ARG3);
   return nullptr;
 }
 

lldb/test/API/lang/swift/async/stepping/step_over_asynclet/Makefile

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

lldb/test/API/lang/swift/async/stepping/step_over_asynclet/TestSwiftAsyncStepOverAsyncLet.py

@@ -0,0 +1,36 @@
+import lldb
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbtest as lldbtest
+import lldbsuite.test.lldbutil as lldbutil
+
+
+@skipIfAsan  # rdar://138777205
+class TestCase(lldbtest.TestBase):
+
+    def check_is_in_line(self, thread, linenum):
+        frame = thread.frames[0]
+        line_entry = frame.GetLineEntry()
+        self.assertEqual(linenum, line_entry.GetLine())
+
+    @swiftTest
+    @skipIf(oslist=["windows", "linux"])
+    def test(self):
+        """Test conditions for async step-over."""
+        self.build()
+
+        source_file = lldb.SBFileSpec("main.swift")
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, "BREAK HERE", source_file
+        )
+
+        # Step over should reach every line in the interval [10, 20]
+        expected_line_nums = [10, 11, 12, 13, 14, 15]
+        # FIXME: for some reason we loop back to the start of the do block after the last statement.
+        # rdar://140159600
+        expected_line_nums += [8]
+        expected_line_nums += [17, 18, 19, 20]
+        for expected_line_num in expected_line_nums:
+            thread.StepOver()
+            stop_reason = thread.GetStopReason()
+            self.assertStopReason(stop_reason, lldb.eStopReasonPlanComplete)
+            self.check_is_in_line(thread, expected_line_num)

lldb/test/API/lang/swift/async/stepping/step_over_asynclet/main.swift

@@ -0,0 +1,27 @@
+func getTimestamp(x: Int) async -> Int {
+  return 40 + x
+}
+
+func work() {}
+
+func foo() async {
+  do {
+    work() // BREAK HERE
+    async let timestamp1 = getTimestamp(x:1)
+    work()
+    async let timestamp2 = getTimestamp(x:2)
+    work()
+    let timestamps = await [timestamp1, timestamp2]
+    print(timestamps)
+  }
+  async let timestamp3 = getTimestamp(x:3)
+  work()
+  let actual_timestamp3 = await timestamp3
+  print(actual_timestamp3)
+}
+
+@main enum entry {
+  static func main() async {
+    await foo()
+  }
+}