[lldb] Implement swift diagnostic for non-captured vars in "frame var"

This commit implements SwiftLanguage::GetParentNameIfClosure,
effectively adding support for diagnosing when a `frame var` command
inside a closure targets a variable that was not captured.

Author: felipepiovezan

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

@@ -2001,6 +2001,11 @@ SwiftLanguage::AreEqualForFrameComparison(const SymbolContext &sc1,
   llvm_unreachable("unhandled enumeration in AreEquivalentFunctions");
 }
 
+std::string
+SwiftLanguage::GetParentNameIfClosure(llvm::StringRef mangled_name) const {
+  return SwiftLanguageRuntime::GetParentNameIfClosure(mangled_name);
+}
+
 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------

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

@@ -205,6 +205,8 @@ class SwiftLanguageRuntime : public LanguageRuntime {
                          const SymbolContext *sc = nullptr,
                          const ExecutionContext *exe_ctx = nullptr);
 
+  static std::string GetParentNameIfClosure(llvm::StringRef mangled_name);
+
   /// Demangle a symbol to a swift::Demangle node tree.
   ///
   /// This is a central point of access, for purposes such as logging.

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

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
 #include "SwiftLanguageRuntime.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
@@ -74,6 +75,34 @@ childAtPath(swift::Demangle::NodePointer node,
   return nullptr;
 }
 
+namespace {
+using NodePointer = swift::Demangle::NodePointer;
+using Node = swift::Demangle::Node;
+
+/// Returns the first child of `node` whose kind is in `kinds`.
+NodePointer getFirstChildOfKind(NodePointer node,
+                                llvm::ArrayRef<Node::Kind> kinds) {
+  if (!node)
+    return nullptr;
+  for (auto *child : *node)
+    if (llvm::is_contained(kinds, child->getKind()))
+      return child;
+  return nullptr;
+}
+
+/// Assumes that `to_replace` is a child of `parent`, and replaces it with
+/// `new_child`. The Nodes must all be owned by the same context.
+void replaceChildWith(Node &parent, Node &to_replace, Node &new_child) {
+  for (unsigned idx = 0; idx < parent.getNumChildren(); idx++) {
+    auto *child = parent.getChild(idx);
+    if (child == &to_replace)
+      parent.replaceChild(idx, &new_child);
+    return;
+  }
+  llvm_unreachable("invalid child passed to replaceChildWith");
+}
+} // namespace
+
 static bool hasChild(swift::Demangle::NodePointer node,
                      swift::Demangle::Node::Kind kind) {
   return childAtPath(node, {kind});
@@ -1496,4 +1525,29 @@ SwiftLanguageRuntime::GetGenericSignature(llvm::StringRef function_name,
   return signature;
 }
 
+std::string SwiftLanguageRuntime::GetParentNameIfClosure(StringRef name) {
+  using Kind = Node::Kind;
+  swift::Demangle::Context ctx;
+  auto *node = SwiftLanguageRuntime::DemangleSymbolAsNode(name, ctx);
+  if (!node || node->getKind() != Node::Kind::Global)
+    return "";
+
+  // Replace the top level closure node with the child function-like node, and
+  // attempt to remangle. If successful, this produces the parent function-like
+  // entity.
+  static const auto closure_kinds = {Kind::ImplicitClosure,
+                                     Kind::ExplicitClosure};
+  static const auto function_kinds = {Kind::ImplicitClosure,
+                                      Kind::ExplicitClosure, Kind::Function};
+  auto *closure_node = getFirstChildOfKind(node, closure_kinds);
+  auto *parent_func_node = getFirstChildOfKind(closure_node, function_kinds);
+  if (!parent_func_node)
+    return "";
+  replaceChildWith(*node, *closure_node, *parent_func_node);
+
+  if (ManglingErrorOr<std::string> mangled = swift::Demangle::mangleNode(node);
+      mangled.isSuccess())
+    return mangled.result();
+  return "";
+}
 } // namespace lldb_private

lldb/source/Target/StackFrame.cpp

@@ -480,7 +480,7 @@ VariableList *StackFrame::GetVariableList(bool get_file_globals,
 // Implement LanguageCPlusPlus::GetParentNameIfClosure and upstream this.
 // rdar://152321823
 
-/// If `sc` represents a "closure-like" function according to `lang, and
+/// If `sc` represents a "closure-like" function according to `lang`, and
 /// `missing_var_name` can be found in a parent context, create a diagnostic
 /// explaining that this variable is available but not captured by the closure.
 static std::string

lldb/test/API/lang/swift/closures_var_not_captured/Makefile

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

lldb/test/API/lang/swift/closures_var_not_captured/TestSwiftClosureVarNotCaptured.py

@@ -0,0 +1,70 @@
+"""
+Test that we can print and call closures passed in various contexts
+"""
+
+import os
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+
+def check_not_captured_error(test, frame, var_name, parent_function):
+    expected_error = (
+        f"A variable named '{var_name}' exists in function '{parent_function}'"
+    )
+    test.expect(f"frame variable {var_name}", substrs=[expected_error], error=True)
+    test.expect(f"frame variable {var_name} + 1", substrs=[expected_error], error=True)
+
+
+class TestSwiftClosureVarNotCaptured(TestBase):
+    def get_to_bkpt(self, bkpt_name):
+        return lldbutil.run_to_source_breakpoint(
+            self, bkpt_name, lldb.SBFileSpec("main.swift")
+        )
+
+    def simple_closure(self):
+        (target, process, thread, bkpt) = self.get_to_bkpt("break_simple_closure")
+        check_not_captured_error(self, thread.frames[0], "var_in_foo", "func_1(arg:)")
+        check_not_captured_error(self, thread.frames[0], "arg", "func_1(arg:)")
+
+    def nested_closure(self):
+        (target, process, thread, bkpt) = self.get_to_bkpt("break_double_closure_1")
+        check_not_captured_error(self, thread.frames[0], "var_in_foo", "func_2(arg:)")
+        check_not_captured_error(self, thread.frames[0], "arg", "func_2(arg:)")
+        check_not_captured_error(
+            self, thread.frames[0], "var_in_outer_closure", "closure #1 in func_2(arg:)"
+        )
+
+        lldbutil.continue_to_source_breakpoint(
+            self, process, "break_double_closure_2", lldb.SBFileSpec("main.swift")
+        )
+        check_not_captured_error(self, thread.frames[0], "var_in_foo", "func_2(arg:)")
+        check_not_captured_error(self, thread.frames[0], "arg", "func_2(arg:)")
+        check_not_captured_error(
+            self, thread.frames[0], "var_in_outer_closure", "closure #1 in func_2(arg:)"
+        )
+
+    def async_closure(self):
+        (target, process, thread, bkpt) = self.get_to_bkpt("break_async_closure_1")
+        check_not_captured_error(self, thread.frames[0], "var_in_foo", "func_3(arg:)")
+        check_not_captured_error(self, thread.frames[0], "arg", "func_3(arg:)")
+        check_not_captured_error(
+            self, thread.frames[0], "var_in_outer_closure", "closure #1 in func_3(arg:)"
+        )
+
+        lldbutil.continue_to_source_breakpoint(
+            self, process, "break_async_closure_2", lldb.SBFileSpec("main.swift")
+        )
+        check_not_captured_error(self, thread.frames[0], "var_in_foo", "func_3(arg:)")
+        check_not_captured_error(self, thread.frames[0], "arg", "func_3(arg:)")
+        check_not_captured_error(
+            self, thread.frames[0], "var_in_outer_closure", "closure #1 in func_3(arg:)"
+        )
+
+    def test(self):
+        self.build()
+        self.simple_closure()
+        self.nested_closure()
+        self.async_closure()

lldb/test/API/lang/swift/closures_var_not_captured/main.swift

@@ -0,0 +1,56 @@
+func func_1(arg:Int) {
+  let var_in_foo = "Alice"
+  let simple_closure = {
+      print("Hi there!")  // break_simple_closure
+  }
+  simple_closure()
+}
+
+func func_2(arg: Int) {
+  let var_in_foo = "Alice"
+  let outer_closure = {
+    let var_in_outer_closure = "Alice"
+    let inner_closure_1 = {
+        print("Hi inside!")  // break_double_closure_1
+    }
+    inner_closure_1()
+
+    let inner_closure_2 = {
+        print("Hi inside!")  // break_double_closure_2
+    }
+    inner_closure_2()
+  }
+  outer_closure()
+}
+
+func func_3(arg:Int) async {
+  let var_in_foo = "Alice"
+
+  // FIXME: if we comment the line below, the test fails. For some reason,
+  // without this line, most variables don't have debug info in the entry
+  // funclet, which is the "parent name" derived from the closure name.
+  // rdar://152271048
+  try! await Task.sleep(for: .seconds(0))
+
+  let outer_closure = {
+    let var_in_outer_closure = "Alice"
+
+    let inner_closure_1 = {
+        print("Hi inside!")  // break_async_closure_1
+    }
+    inner_closure_1()
+
+    try await Task.sleep(for: .seconds(0))
+
+    let inner_closure_2 = {
+        print("Hi inside!")  // break_async_closure_2
+    }
+    inner_closure_2()
+  }
+
+  try! await outer_closure()
+}
+
+func_1(arg:42)
+func_2(arg:42)
+await func_3(arg:42)