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

This commit implements the same diagnostic that was previously
implemented for frame var. The strategy here is slightly different due
to how expression evaluation works.

We have to pattern match this diagnostic from the compiler:

```
error: <EXPR>:6:1: cannot find 'NAME' in scope
1 + NAME
    ^~~~
```

If we find it, we trigger the usual search for a variable named `NAME`.
If it is found, the diagnostic is replaced with:

```
error: <EXPR>:6:5: Current frame is a closure.
A variable named 'NAME' exists in function 'foo(_:)', but it was not captured.
Hint: the variable may be available in a parent frame.
1 + NAME
    ^~~~
```

Implementation note: the pattern matching could be a _lot_ simpler if we
don't insist on replacing the original diagnostic and, instead, append
to it.

Author: felipepiovezan

lldb/source/Plugins/ExpressionParser/Swift/SwiftUserExpression.cpp

@@ -35,6 +35,7 @@
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
@@ -693,6 +694,95 @@ SwiftUserExpression::GetTextAndSetExpressionParser(
   return parse_result;
 }
 
+/// If `sc` represents a "closure-like" function according to `lang`, and
+/// `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
+CreateVarInParentScopeDiagnostic(StringRef var_name,
+                                 StringRef parent_func_name) {
+  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.",
+                       var_name, parent_func_name);
+}
+
+namespace {
+/// Helper class to match the following two diagnostics emitted by the compiler:
+//     (.*): cannot find '([^']+)' in scope\n(.*)");
+//     (.*): use of undeclared identifier '([^']+)'\n(.*)");
+//  The first group is stored in "prefix", the middle group in "var_name", and
+//  the final group in "suffix".
+struct VariableNotFoundDiagnosticMatcher {
+  static std::optional<VariableNotFoundDiagnosticMatcher>
+  match(StringRef diagnostic) {
+    llvm::SmallVector<StringRef, 4> match_groups;
+    if (not_in_scope_regex1.Execute(diagnostic, &match_groups) ||
+        not_in_scope_regex2.Execute(diagnostic, &match_groups))
+      return VariableNotFoundDiagnosticMatcher{match_groups[1], match_groups[2],
+                                               match_groups[3]};
+    return {};
+  }
+
+  StringRef prefix;
+  StringRef var_name;
+  StringRef suffix;
+
+private:
+  static const RegularExpression not_in_scope_regex1;
+  static const RegularExpression not_in_scope_regex2;
+};
+const RegularExpression VariableNotFoundDiagnosticMatcher::not_in_scope_regex1 =
+    RegularExpression("(.*): cannot find '([^']+)' in scope\n(.*)");
+const RegularExpression VariableNotFoundDiagnosticMatcher::not_in_scope_regex2 =
+    RegularExpression("(.*): use of undeclared identifier '([^']+)'\n(.*)");
+} // namespace
+
+/// If `diagnostic_manager` contains a "cannot find <var_name> in scope"
+/// diagnostic, attempt to enhance it by showing if `var_name` is used inside a
+/// closure, not captured, but defined in a parent scope.
+static void EnhanceNotInScopeDiagnostics(DiagnosticManager &diagnostic_manager,
+                                         ExecutionContextScope *exe_scope) {
+  if (!exe_scope)
+    return;
+  lldb::StackFrameSP stack_frame = exe_scope->CalculateStackFrame();
+  if (!stack_frame)
+    return;
+  SymbolContext sc =
+      stack_frame->GetSymbolContext(lldb::eSymbolContextEverything);
+  Language *swift_lang =
+      Language::FindPlugin(lldb::LanguageType::eLanguageTypeSwift);
+  if (!swift_lang)
+    return;
+
+  for (auto &diag : diagnostic_manager.Diagnostics()) {
+    if (!diag)
+      continue;
+
+    StringRef old_rendered_msg = diag->GetDetail().rendered;
+    std::optional<VariableNotFoundDiagnosticMatcher> matched_diag =
+        VariableNotFoundDiagnosticMatcher::match(old_rendered_msg);
+    if (!matched_diag)
+      continue;
+
+    Function *parent_func =
+        swift_lang->FindParentOfClosureWithVariable(matched_diag->var_name, sc);
+    if (!parent_func)
+      continue;
+    std::string new_message = CreateVarInParentScopeDiagnostic(
+        matched_diag->var_name, parent_func->GetDisplayName());
+
+    std::string new_rendered =
+        llvm::formatv("{0}: {1}\n{2}", matched_diag->prefix, new_message,
+                      matched_diag->suffix);
+    const DiagnosticDetail &old_detail = diag->GetDetail();
+    diag = std::make_unique<Diagnostic>(
+        diag->getKind(), diag->GetCompilerID(),
+        DiagnosticDetail{old_detail.source_location, old_detail.severity,
+                         std::move(new_message), std::move(new_rendered)});
+  }
+}
+
 bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
                                 ExecutionContext &exe_ctx,
                                 lldb_private::ExecutionPolicy execution_policy,
@@ -888,6 +978,7 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
                 fixed_expression.substr(fixed_start, fixed_end - fixed_start);
         }
       }
+      EnhanceNotInScopeDiagnostics(diagnostic_manager, exe_scope);
       return false;
     case ParseResult::success:
       llvm_unreachable("Success case is checked separately before switch!");

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

@@ -14,6 +14,14 @@ def check_not_captured_error(test, frame, var_name, parent_function):
     expected_error = (
         f"A variable named '{var_name}' exists in function '{parent_function}'"
     )
+    value = frame.EvaluateExpression(var_name)
+    error = value.GetError().GetCString()
+    test.assertIn(expected_error, error)
+
+    value = frame.EvaluateExpression(f"1 + {var_name} + 1")
+    error = value.GetError().GetCString()
+    test.assertIn(expected_error, error)
+
     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)