[lldb] Fix crash when tab-completing in multi-line expr

[teemperor]

Summary

Tab completing inside the multiline expression command can cause LLDB to crash. The easiest way
to do this is to go inside a frame with at least one local variable and then try to complete:

(lldb) expr
1. a[tab]

Reason for this was some mixup when we calculate the cursor position. Obviously we should calculate
the offset inside the string by doing 'end - start', but we are doing 'start - end' (which causes the offset to
become -1 which will lead to some out-of-bounds reading).

Fixes rdar://51754005

I don't see any way to test this as the *multiline* expression completion is completely untested at the moment
and I don't think we have any existing code for testing infrastructure for it.

[teemperor]

I don't see any way to test this as the *multiline* expression completion is completely untested at the moment and I don't think we have any existing code for testing infrastructure for it.

Correct me if I'm wrong with this. I know we never test this functionality (as the whole IOHandler business is tricky to test), but I'm not sure if we maybe have some funky way around it.

Otherwise I would say we merge this as-is, as I don't want to have an obvious bug around until we find a method to test the interactive IO code.

[labath]

This looks like a good opportunity to unleash pexpect.

[davide]

See if you can write a pexpect test, as Pavel suggested.

[shafik]

Also once we get one test going then it should be easy to add coverage for all sorts of scenarios. Who knows maybe we will find more bugs.

[teemperor]

• Added test.

[labath]

Thanks. The test looks good to me. You might want to consider marking it as NO_DEBUG_INFO_TESTCASE.

lldb/trunk/packages/Python/lldbsuite/test/expression_command/multiline-completion/Makefile

+LEVEL = ../../make
+C_SOURCES := main.c
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/expression_command/multiline-completion/TestMultilineCompletion.py

+"""
+Test completion for multiline expressions.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+
+class MultilineCompletionTest(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.source = 'main.c'
+
+    def expect_string(self, string):
+        import pexpect
+        """This expects for "string", with timeout & EOF being test fails."""
+        try:
+            self.child.expect_exact(string)
+        except pexpect.EOF:
+            self.fail("Got EOF waiting for '%s'" % (string))
+        except pexpect.TIMEOUT:
+            self.fail("Timed out waiting for '%s'" % (string))
+
+    @expectedFailureAll(
+        oslist=["windows"],
+        bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
+    def test_basic_completion(self):
+        """Test that we can complete a simple multiline expression"""
+        self.build()
+        self.setTearDownCleanup()
+
+        import pexpect
+        exe = self.getBuildArtifact("a.out")
+        prompt = "(lldb) "
+
+        run_commands = ' -o "b main" -o "r"'
+        self.child = pexpect.spawn(
+            '%s %s %s %s' %
+            (lldbtest_config.lldbExec, self.lldbOption, run_commands, exe))
+        child = self.child
+
+        self.expect_string(prompt)
+        self.child.sendline("expr")
+        self.expect_string("terminate with an empty line to evaluate")
+        self.child.send("to_\t")
+        self.expect_string("to_complete")
+
+        self.deletePexpectChild()

lldb/trunk/packages/Python/lldbsuite/test/expression_command/multiline-completion/main.c

+int main(int argc, char **argv) {
+  lldb_enable_attach();
+  int to_complete = 0;
+  return to_complete;
+}

lldb/trunk/source/Core/IOHandler.cpp

case Completion::None:
     break;
 
   case Completion::LLDBCommand:
     return io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(
         current_line, cursor, last_char, skip_first_n_matches, max_matches,
         matches, descriptions);
   case Completion::Expression: {
     CompletionResult result;
-    CompletionRequest request(current_line, current_line - cursor,
+    CompletionRequest request(current_line, cursor - current_line,
                               skip_first_n_matches, max_matches, result);
     CommandCompletions::InvokeCommonCompletionCallbacks(
         io_handler.GetDebugger().GetCommandInterpreter(),
         CommandCompletions::eVariablePathCompletion, request, nullptr);
     result.GetMatches(matches);
     result.GetDescriptions(descriptions);
 
     size_t num_matches = request.GetNumberOfMatches();