Merge pull request #8694 from adrian-prantl/127123509

Make the user code range detection more robust.

Author: adrian-prantl

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

@@ -502,7 +502,6 @@ func $__lldb_expr(_ $__lldb_arg : UnsafeMutablePointer<Any>) {
                             wrapped_expr_text.GetData(), availability.c_str(),
                             current_counter);
     }
-    first_body_line = 5;
   } else if (options.GetBindGenericTypes() == lldb::eDontBind) {
     auto c = MakeGenericSignaturesAndCalls(local_variables, generic_sig,
                                            needs_object_ptr);
@@ -536,7 +535,6 @@ func $__lldb_expr(_ $__lldb_arg : UnsafeMutablePointer<Any>) {
         "%s" // This is the expression text (with newlines).
         "}\n",
         availability.c_str(), wrapped_expr_text.GetData());
-    first_body_line = 4;
   }
   return status;
 }
@@ -564,8 +562,6 @@ Status SwiftExpressionSourceCode::GetText(
     llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) const {
   Status status;
   Target *target = exe_ctx.GetTargetPtr();
-
-
   if (m_wrap) {
     const char *body = m_body.c_str();
     const char *pound_file = options.GetPoundLineFilePath();
@@ -630,7 +626,8 @@ Status SwiftExpressionSourceCode::GetText(
     bool need_to_declare_log_functions = num_persistent_results == 0;
     EvaluateExpressionOptions localOptions(options);
 
-    localOptions.SetPreparePlaygroundStubFunctions(need_to_declare_log_functions);
+    localOptions.SetPreparePlaygroundStubFunctions(
+        need_to_declare_log_functions);
 
     std::string full_body = m_prefix + m_body;
     status = WrapExpression(wrap_stream, full_body.c_str(), needs_object_ptr,
@@ -645,23 +642,34 @@ Status SwiftExpressionSourceCode::GetText(
     text.append(m_body);
   }
 
+  if (!first_body_line) {
+    // If this is not a playground or REPL expression, compute the
+    // first line, by locating the marker. While this could be
+    // determined statically, it's more future-proof to calculate it
+    // here.
+    uint32_t start_idx, end_idx;
+    if (GetOriginalBodyBounds(text, start_idx, end_idx))
+      first_body_line =
+          StringRef(text.data(), text.size() - start_idx).count('\n') + 1;
+  }
   return status;
 }
 
 bool SwiftExpressionSourceCode::GetOriginalBodyBounds(
-    std::string transformed_text,
-    size_t &start_loc, size_t &end_loc) {
-  const char *start_marker;
-  const char *end_marker;
-
-  start_marker = GetUserCodeStartMarker();
-  end_marker = GetUserCodeEndMarker();
+    std::string transformed_text, uint32_t &start_loc, uint32_t &end_loc) {
+  StringRef start_marker = GetUserCodeStartMarker();
+  StringRef end_marker = GetUserCodeEndMarker();
+  size_t found_loc = transformed_text.find(start_marker);
+  if (found_loc == StringRef::npos ||
+      found_loc > std::numeric_limits<uint32_t>::max())
+    return false;
+  start_loc = found_loc;
 
-  start_loc = transformed_text.find(start_marker);
-  if (start_loc == std::string::npos)
+  start_loc += start_marker.size();
+  found_loc = transformed_text.find(end_marker);
+  if (found_loc == StringRef::npos ||
+      found_loc > std::numeric_limits<uint32_t>::max())
     return false;
-  start_loc += strlen(start_marker);
-  end_loc = transformed_text.find(end_marker);
-  return end_loc != std::string::npos;
-  return false;
+  end_loc = found_loc;
+  return true;
 }

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionSourceCode.h

@@ -38,7 +38,7 @@ class SwiftExpressionSourceCode : public ExpressionSourceCode {
   // passed to CreateWrapped. Return true if the bounds could be found.  This
   // will also work on text with FixItHints applied.
   static bool GetOriginalBodyBounds(std::string transformed_text,
-                                    size_t &start_loc, size_t &end_loc);
+                                    uint32_t &start_loc, uint32_t &end_loc);
 
   uint32_t GetNumBodyLines();
 
@@ -51,8 +51,8 @@ class SwiftExpressionSourceCode : public ExpressionSourceCode {
       llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) const;
 
 private:
-  SwiftExpressionSourceCode(const char *name, const char *prefix, const char *body,
-                       Wrapping wrap)
+  SwiftExpressionSourceCode(const char *name, const char *prefix,
+                            const char *body, Wrapping wrap)
       : ExpressionSourceCode(name, prefix, body, wrap) {}
   uint32_t m_num_body_lines = 0;
 };

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

@@ -828,8 +828,8 @@ exe_scope = exe_ctx.GetBestExecutionContextScope();
       // If fixits are enabled, calculate the fixed expression string.
       if (m_options.GetAutoApplyFixIts() && diagnostic_manager.HasFixIts()) {
         if (m_parser->RewriteExpression(diagnostic_manager)) {
-          size_t fixed_start;
-          size_t fixed_end;
+          uint32_t fixed_start;
+          uint32_t fixed_end;
           const std::string &fixed_expression =
               diagnostic_manager.GetFixedExpression();
           if (SwiftExpressionSourceCode::GetOriginalBodyBounds(

lldb/test/API/lang/swift/expression/error_reporting/Makefile

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

lldb/test/API/lang/swift/expression/error_reporting/TestSwiftExpressionErrorReporting.py

@@ -0,0 +1,33 @@
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import unittest2
+
+class TestSwiftExpressionErrorReportingy(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @swiftTest
+    def test(self):
+        """Test error reporting in expressions reports
+        only diagnostics in user code"""
+        self.build()
+        target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
+            self, 'break here', lldb.SBFileSpec('main.swift'))
+
+        options = lldb.SBExpressionOptions()
+        value = self.frame().EvaluateExpression(
+            "ceciNestPasUnVar", options)
+        def check(value):
+            lines = str(value.GetError()).split('\n')
+            self.assertTrue(lines[0].startswith('error:'))
+            self.assertIn('ceciNestPasUnVar', lines[0])
+            for line in lines[1:]:
+                self.assertFalse(line.startswith('error:'))
+                self.assertFalse(line.startswith('warning:'))
+
+        check(value)
+        process.Continue()
+        value = self.frame().EvaluateExpression(
+            "ceciNestPasUnVar", options)
+        check(value)

lldb/test/API/lang/swift/expression/error_reporting/main.swift

@@ -0,0 +1,15 @@
+class State {
+  init(x: Int) {
+    number = x
+    print("in class") // break here
+  }
+
+  var number:Int
+}
+
+func f() {
+  print("in function") // break here
+}
+
+f()
+State(x: 20)