[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/Language/Swift/SwiftLanguage.h

@@ -81,6 +81,9 @@ class SwiftLanguage : public Language {
   std::optional<bool>
   AreEqualForFrameComparison(const SymbolContext &sc1,
                              const SymbolContext &sc2) const override;
+
+  std::string
+  GetParentNameIfClosure(llvm::StringRef mangled_name) const override;
   //------------------------------------------------------------------
   // 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,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
+#include "Plugins/TypeSystem/Swift/SwiftDemangle.h"
 #include "SwiftLanguageRuntime.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
@@ -1496,4 +1498,30 @@ 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 = swift_demangle::GetFirstChildOfKind(node, closure_kinds);
+  auto *parent_func_node =
+      swift_demangle::GetFirstChildOfKind(closure_node, function_kinds);
+  if (!parent_func_node)
+    return "";
+  swift_demangle::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/Plugins/TypeSystem/Swift/SwiftDemangle.h

@@ -22,6 +22,32 @@
 namespace lldb_private {
 namespace swift_demangle {
 
+using NodePointer = swift::Demangle::NodePointer;
+using Node = swift::Demangle::Node;
+
+/// Returns the first child of `node` whose kind is in `kinds`.
+inline 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.
+inline 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");
+}
+
 /// Access an inner node by following the given Node::Kind path.
 ///
 /// Note: The Node::Kind path is relative to the given root node. The root

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,97 @@
+"""
+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}' existed in function '{parent_function}'"
+    )
+    test.expect(f"frame variable {var_name}", substrs=[expected_error], error=True)
+
+
+def check_no_enhanced_diagnostic(test, frame, var_name):
+    forbidden_str = "A variable named"
+    value = frame.EvaluateExpression(var_name)
+    error = value.GetError().GetCString()
+    test.assertNotIn(forbidden_str, error)
+
+    value = frame.EvaluateExpression(f"1 + {var_name} + 1")
+    error = value.GetError().GetCString()
+    test.assertNotIn(forbidden_str, error)
+
+    test.expect(
+        f"frame variable {var_name}",
+        substrs=[forbidden_str],
+        matching=False,
+        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")
+        )
+
+    @swiftTest
+    def test_simple_closure(self):
+        self.build()
+        (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:)")
+        check_no_enhanced_diagnostic(self, thread.frames[0], "dont_find_me")
+
+    @swiftTest
+    def test_nested_closure(self):
+        self.build()
+        (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:)"
+        )
+        check_no_enhanced_diagnostic(self, thread.frames[0], "dont_find_me")
+
+        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:)"
+        )
+        check_not_captured_error(
+            self, thread.frames[0], "shadowed_var", "closure #1 in func_2(arg:)"
+        )
+        check_no_enhanced_diagnostic(self, thread.frames[0], "dont_find_me")
+
+    @swiftTest
+    # Async variable inspection on Linux/Windows are still problematic.
+    @skipIf(oslist=["windows", "linux"])
+    def test_async_closure(self):
+        self.build()
+        (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:)"
+        )
+        check_no_enhanced_diagnostic(self, thread.frames[0], "dont_find_me")
+
+        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:)"
+        )
+        check_no_enhanced_diagnostic(self, thread.frames[0], "dont_find_me")

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

@@ -0,0 +1,92 @@
+func func_1(arg: Int) {
+  let var_in_foo = "Alice"
+  do {
+    let dont_find_me = "haha"
+    print(dont_find_me)
+  }
+  let simple_closure = {
+    print("Hi there!")  // break_simple_closure
+  }
+  simple_closure()
+  let dont_find_me = "haha"
+  print(dont_find_me)
+}
+
+func func_2(arg: Int) {
+  do {
+    let dont_find_me = "haha"
+    print(dont_find_me)
+  }
+  let var_in_foo = "Alice"
+  let shadowed_var = "shadow"
+  let outer_closure = {
+    do {
+      let dont_find_me = "haha"
+      print(dont_find_me)
+    }
+    let var_in_outer_closure = "Alice"
+    let shadowed_var = "shadow2"
+    let inner_closure_1 = {
+      print("Hi inside!")  // break_double_closure_1
+    }
+    inner_closure_1()
+
+    do {
+      let dont_find_me = "haha"
+      print(dont_find_me)
+    }
+    let inner_closure_2 = {
+      print("Hi inside!")  // break_double_closure_2
+    }
+    inner_closure_2()
+    let dont_find_me = "haha"
+    print(dont_find_me)
+  }
+  let dont_find_me = "haha"
+  print(dont_find_me)
+  outer_closure()
+}
+
+func func_3(arg: Int) async {
+  do {
+    let dont_find_me = "haha"
+    print(dont_find_me)
+  }
+  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 = {
+    do {
+      let dont_find_me = "haha"
+      print(dont_find_me)
+    }
+    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()
+    let dont_find_me = "haha"
+    print(dont_find_me)
+  }
+
+  try! await outer_closure()
+  let dont_find_me = "haha"
+  print(dont_find_me)
+}
+
+func_1(arg: 42)
+func_2(arg: 42)
+await func_3(arg: 42)