[lldb][NFCI] Implement language-agnostic diagnostic for non-captured vars in "frame var"

This commit adds the language-agnostic logic to support diagnosing when
a `frame var` command failed because a variable is not visible in the
current frame, but the current frame is a "closure-like"(*) function and
it could have access to the variable, had it been captured by the
closure.

(*) A lambda in C++, a block in C or Objective C, a closure in Swift.

The logic relies on language plugins being able to produce the name of
the function where the current closure is defined, given the mangled
name of the closure. Since this commit does not implement support for
this in any languages, it is NFCI. It contains all the necessary pieces
to upstream the code, once we implement Language support for at least
one upstream language.

Author: felipepiovezan

lldb/include/lldb/Target/Language.h

@@ -403,6 +403,28 @@ class Language : public PluginInterface {
     return nullptr;
   }
 
+  // BEGIN SWIFT
+  // Implement LanguageCPlusPlus::GetParentNameIfClosure and upstream this.
+  // rdar://152321823
+
+  /// If `mangled_name` refers to a function that is a "closure-like" function,
+  /// returns the name of the parent function where the input closure was
+  /// defined. Returns an empty string if there is no such parent, or if the
+  /// query does not make sense for this language.
+  virtual std::string
+  GetParentNameIfClosure(llvm::StringRef mangled_name) const {
+    return "";
+  }
+
+  /// If `sc` corresponds to a "closure-like" function (as defined in
+  /// `GetParentNameIfClosure`), returns the parent Function*
+  /// where a variable named `variable_name` exists.
+  /// Returns nullptr if `sc` is not a closure, or if the query does
+  /// not make sense for this language.
+  Function *FindParentOfClosureWithVariable(llvm::StringRef variable_name,
+                                            const SymbolContext &sc) const;
+  // END SWIFT
+
 protected:
   // Classes that inherit from Language can see and modify these
 

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

@@ -81,6 +81,7 @@ class SwiftLanguage : public Language {
   std::optional<bool>
   AreEqualForFrameComparison(const SymbolContext &sc1,
                              const SymbolContext &sc2) const override;
+
   //------------------------------------------------------------------
   // Static Functions
   //------------------------------------------------------------------

lldb/source/Target/Language.cpp

@@ -16,9 +16,11 @@
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
+#include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Stream.h"
 
+#include "llvm/ADT/MapVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Support/Threading.h"
 
@@ -574,3 +576,76 @@ bool SourceLanguage::IsObjC() const {
 bool SourceLanguage::IsCPlusPlus() const {
   return name == llvm::dwarf::DW_LNAME_C_plus_plus;
 }
+
+// BEGIN SWIFT
+// Implement LanguageCPlusPlus::GetParentNameIfClosure and upstream this.
+// rdar://152321823
+
+/// If `sc` represents a "closure"-like function (according to
+/// Language::GetParentNameIfClosure), returns all parent functions up to and
+/// including the first non-closure-like function. If `sc` is not a closure, or
+/// if the query does not make sense for `language`, returns an empty list.
+static llvm::SmallVector<Function *>
+GetParentFunctionsWhileClosure(const SymbolContext &sc,
+                               const Language &language) {
+  // The algorithm below terminates on the assumption that
+  // `GetParentNameIfClosure` produces an empty string when composing that
+  // function with itself enough times. For safety, define an upper limit.
+  constexpr auto upper_limit = 8;
+
+  llvm::SmallVector<Function *> parents;
+  Function *root = sc.function;
+  if (root == nullptr)
+    return parents;
+
+  for (int idx = 0; idx < upper_limit; idx++) {
+    ConstString mangled = root->GetMangled().GetMangledName();
+    std::string parent = language.GetParentNameIfClosure(mangled);
+    if (parent.empty())
+      break;
+
+    // Find the enclosing function, if it exists.
+    SymbolContextList sc_list;
+    Module::LookupInfo lookup_info(
+        ConstString(parent), lldb::FunctionNameType::eFunctionNameTypeFull,
+        lldb::eLanguageTypeSwift);
+    sc.module_sp->FindFunctions(lookup_info, CompilerDeclContext(),
+                                ModuleFunctionSearchOptions(), sc_list);
+    if (sc_list.GetSize() != 1 || sc_list[0].function == nullptr)
+      break;
+    parents.push_back(sc_list[0].function);
+    root = sc_list[0].function;
+  }
+  return parents;
+}
+
+/// Given a list of functions, returns a map: Function -> VariableList
+/// containing local variables of each function.
+static llvm::MapVector<Function *, VariableList>
+GetFuncToLocalVariablesMap(llvm::ArrayRef<Function *> funcs) {
+  llvm::MapVector<Function *, VariableList> map;
+  for (Function *function : funcs) {
+    VariableList &variable_list = map[function];
+    Block &block = function->GetBlock(true /*can_create=*/);
+    block.AppendBlockVariables(
+        true /*can_create=*/, true /*get_child_block_variables=*/,
+        true /*stop_if_child_block_is_inlined_function=*/,
+        [](Variable *v) { return true; }, &variable_list);
+  }
+  return map;
+}
+
+Function *Language::FindParentOfClosureWithVariable(
+    llvm::StringRef variable_name, const SymbolContext &closure_sc) const {
+  llvm::SmallVector<Function *> parent_funcs =
+      GetParentFunctionsWhileClosure(closure_sc, *this);
+  llvm::MapVector<Function *, VariableList> func_to_locals =
+      GetFuncToLocalVariablesMap(parent_funcs);
+
+  for (const auto &[func, locals] : func_to_locals)
+    for (const VariableSP &var_sp : locals)
+      if (var_sp->GetName() == variable_name)
+        return func;
+  return nullptr;
+}
+// END SWIFT

lldb/source/Target/StackFrame.cpp

@@ -22,6 +22,7 @@
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
@@ -475,6 +476,32 @@ VariableList *StackFrame::GetVariableList(bool get_file_globals,
   return m_variable_list_sp.get();
 }
 
+// BEGIN SWIFT
+// Implement LanguageCPlusPlus::GetParentNameIfClosure and upstream this.
+// rdar://152321823
+
+/// 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
+GetVariableNotCapturedDiagnostic(SymbolContext &sc, SourceLanguage lang,
+                                 ConstString missing_var_name) {
+  Language *lang_plugin = Language::FindPlugin(lang.AsLanguageType());
+  if (lang_plugin == nullptr)
+    return "";
+  Function *parent_func =
+      lang_plugin->FindParentOfClosureWithVariable(missing_var_name, sc);
+  if (!parent_func)
+    return "";
+  return llvm::formatv("Current frame is a closure.\nA variable named '{0}' "
+                       "exists in function '{1}', but it "
+                       "was not captured.\nHint: the variable may be available "
+                       "in a parent frame.",
+                       missing_var_name,
+                       parent_func->GetDisplayName().GetStringRef());
+}
+// END SWIFT
+
 VariableListSP
 StackFrame::GetInScopeVariableList(bool get_file_globals,
                                    bool must_have_valid_location) {
@@ -620,6 +647,15 @@ ValueObjectSP StackFrame::GetValueForVariableExpressionPath(
       return valobj_sp;
   }
   if (!valobj_sp) {
+    // BEGIN SWIFT
+    // Implement LanguageCPlusPlus::GetParentNameIfClosure and upstream this.
+    // rdar://152321823
+    if (std::string message = GetVariableNotCapturedDiagnostic(
+            m_sc, GetLanguage(), name_const_string);
+        !message.empty())
+      error = Status::FromErrorString(message.c_str());
+    else
+    // END SWIFT
     error = Status::FromErrorStringWithFormatv(
         "no variable named '{0}' found in this frame", name_const_string);
     return ValueObjectSP();