Add code snippet line numbers to TestExprDiagnostics output

[tbaeder]

Summary

Clang prints a margin with line numbers to the left of code snippets now, introduced in https://reviews.llvm.org/D147875.

This is a patch to fix a lldb test case that was broken due to the above change in clang. We either need to tell clang not to output line numbers in diagnostic code snippets, or the test case needs to be adapted.

[teemperor]

I think, given the support for multi-line expressions, updating the test case is the right call.

[tbaeder]

Can you tell me what I have to do so ninja check-lldb-api actually runs the test? All 1114 tests are currently marked "unsupported" for me.

[Michael137]

In D150772#4349592, @tbaeder wrote:

Can you tell me what I have to do so ninja check-lldb-api actually runs the test? All 1114 tests are currently marked "unsupported" for me.

Did you configure LLDB with -DLLDB_ENABLE_PYTHON? We should probably add that info to https://lldb.llvm.org/resources/test.html#running-the-full-test-suite

[tbaeder]

In D150772#4349595, @Michael137 wrote:

In D150772#4349592, @tbaeder wrote:

Can you tell me what I have to do so ninja check-lldb-api actually runs the test? All 1114 tests are currently marked "unsupported" for me.

Did you configure LLDB with -DLLDB_ENABLE_PYTHON? We should probably add that info to https://lldb.llvm.org/resources/test.html#running-the-full-test-suite

Ah yes, that seems to be the problem. Looks like that won't work when using sanitizers though, so I'll have to do another build and it will take a little longer.

[tbaeder]

Updated the test and split up the expected output into multiple lines so it's easier to read.

[tbaeder]

Ping

[JDevlieghere]

I think this test could benefit from switching to string literals (''') and doing a single self.assertIn rather than scanning the whole output for every line. Also please use black (version 23) to format the test.

[JDevlieghere]

LGTM

[tbaeder]

I merged the changes into the original line number commit and pushed them as https://github.com/llvm/llvm-project/commit/f63155aaa6467bd2610820dfd1996af3bb6029a7

lldb/test/API/commands/expression/diagnostics/TestExprDiagnostics.py

def test_source_and_caret_printing(self):
                                           '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         # Test that source/caret are at the right position.
         value = frame.EvaluateExpression("unknown_identifier")
         self.assertFalse(value.GetError().Success())
         # We should get a nice diagnostic with a caret pointing at the start of
         # the identifier.
-        self.assertIn("\nunknown_identifier\n^\n", value.GetError().GetCString())
+        self.assertIn(
+            """
+    1 | unknown_identifier
+      | ^
+""",
+            value.GetError().GetCString(),
+        )
         self.assertIn("<user expression 0>:1:1", value.GetError().GetCString())
 
         # Same as above but with the identifier in the middle.
-        value = frame.EvaluateExpression("1 + unknown_identifier  ")
+        value = frame.EvaluateExpression("1 + unknown_identifier")
         self.assertFalse(value.GetError().Success())
-        self.assertIn("\n1 + unknown_identifier", value.GetError().GetCString())
-        self.assertIn("\n    ^\n", value.GetError().GetCString())
+        self.assertIn(
+            """
+    1 | 1 + unknown_identifier
+      |     ^
+""",
+            value.GetError().GetCString(),
+        )
 
         # Multiline expressions.
         value = frame.EvaluateExpression("int a = 0;\nfoobar +=1;\na")
         self.assertFalse(value.GetError().Success())
         # We should still get the right line information and caret position.
-        self.assertIn("\nfoobar +=1;\n^\n", value.GetError().GetCString())
+        self.assertIn(
+            """
+    2 | foobar +=1;
+      | ^
+""",
+            value.GetError().GetCString(),
+        )
+
         # It's the second line of the user expression.
         self.assertIn("<user expression 2>:2:1", value.GetError().GetCString())
 
         # Top-level expressions.
         top_level_opts = lldb.SBExpressionOptions();
         top_level_opts.SetTopLevel(True)
 
         value = frame.EvaluateExpression("void foo(unknown_type x) {}", top_level_opts)
         self.assertFalse(value.GetError().Success())
-        self.assertIn("\nvoid foo(unknown_type x) {}\n         ^\n", value.GetError().GetCString())
+        self.assertIn(
+            """
+    1 | void foo(unknown_type x) {}
+      |          ^
+""",
+            value.GetError().GetCString(),
+        )
+
         # Top-level expressions might use a different wrapper code, but the file name should still
         # be the same.
         self.assertIn("<user expression 3>:1:10", value.GetError().GetCString())
 
         # Multiline top-level expressions.
         value = frame.EvaluateExpression("void x() {}\nvoid foo;", top_level_opts)
         self.assertFalse(value.GetError().Success())
-        self.assertIn("\nvoid foo;\n     ^", value.GetError().GetCString())
+        self.assertIn(
+            """
+    2 | void foo;
+      |      ^
+""",
+            value.GetError().GetCString(),
+        )
+
         self.assertIn("<user expression 4>:2:6", value.GetError().GetCString())
 
         # Test that we render Clang's 'notes' correctly.
         value = frame.EvaluateExpression("struct SFoo{}; struct SFoo { int x; };", top_level_opts)
         self.assertFalse(value.GetError().Success())
-        self.assertIn("<user expression 5>:1:8: previous definition is here\nstruct SFoo{}; struct SFoo { int x; };\n       ^\n", value.GetError().GetCString())
+        self.assertIn(
+            "<user expression 5>:1:8: previous definition is here\n",
+            value.GetError().GetCString(),
+        )
+        self.assertIn(
+            """
+    1 | struct SFoo{}; struct SFoo { int x; };
+      |        ^
+""",
+            value.GetError().GetCString(),
+        )
 
         # Declarations from the debug information currently have no debug information. It's not clear what
         # we should do in this case, but we should at least not print anything that's wrong.
         # In the future our declarations should have valid source locations.
         value = frame.EvaluateExpression("struct FooBar { double x };", top_level_opts)
         self.assertFalse(value.GetError().Success())
-        self.assertIn("error: <user expression 6>:1:8: redefinition of 'FooBar'\nstruct FooBar { double x };\n       ^\n", value.GetError().GetCString())
+        self.assertIn(
+            "error: <user expression 6>:1:8: redefinition of 'FooBar'\n",
+            value.GetError().GetCString(),
+        )
+        self.assertIn(
+            """
+    1 | struct FooBar { double x };
+      |        ^
+""",
+            value.GetError().GetCString(),
+        )
 
         value = frame.EvaluateExpression("foo(1, 2)")
         self.assertFalse(value.GetError().Success())
-        self.assertIn("error: <user expression 7>:1:1: no matching function for call to 'foo'\nfoo(1, 2)\n^~~\nnote: candidate function not viable: requires single argument 'x', but 2 arguments were provided\n\n", value.GetError().GetCString())
+        self.assertIn(
+            "error: <user expression 7>:1:1: no matching function for call to 'foo'\n",
+            value.GetError().GetCString(),
+        )
+        self.assertIn(
+            """
+    1 | foo(1, 2)
+      | ^~~
+note: candidate function not viable: requires single argument 'x', but 2 arguments were provided
+""",
+            value.GetError().GetCString(),
+        )
 
         # Redefine something that we defined in a user-expression. We should use the previous expression file name
         # for the original decl.
         value = frame.EvaluateExpression("struct Redef { double x; };", top_level_opts)
         value = frame.EvaluateExpression("struct Redef { float y; };", top_level_opts)
         self.assertFalse(value.GetError().Success())
-        self.assertIn("error: <user expression 9>:1:8: redefinition of 'Redef'\nstruct Redef { float y; };\n       ^\n<user expression 8>:1:8: previous definition is here\nstruct Redef { double x; };\n       ^", value.GetError().GetCString())
+        self.assertIn(
+            """
+error: <user expression 9>:1:8: redefinition of 'Redef'
+    1 | struct Redef { float y; };
+      |        ^
+<user expression 8>:1:8: previous definition is here
+    1 | struct Redef { double x; };
+      |        ^
+""",
+            value.GetError().GetCString(),
+        )
 
     @add_test_categories(["objc"])
     def test_source_locations_from_objc_modules(self):
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)