Added initial code completion support for the `expr` command

[teemperor]

Summary

This patch adds initial code completion support for the expr command.

We now have a completion handler in the expression CommandObject that
essentially just attempts to parse the given user expression with Clang with
an attached code completion consumer. We filter and prepare the
code completions provided by Clang and send them back to the completion
API.

The current completion is limited to variables that are in the current scope.
This includes local variables and all types used by local variables. We however
don't do any completion of symbols that are not used in the local scope (or
in some other way already in the ASTContext).

This is partly because there is not yet any code that manually searches for additiona
information in the debug information. Another cause is that for some reason the existing
code for loading these additional symbols when requested by Clang doesn't seem to work.
This will be fixed in a future patch.

[teemperor]

Note that there are two parent revisions. One is just refactoring because I needed to reuse some of the parsing setup code. The other patch (the AsyncPrint one) fixes a deadlock that affected this patch. The deadlock can be reproduces by starting lldb, going to a random breakpoint in a C++ program and then trying to complete a simple expression like expr some_local_var. lldb will fail to read some Objective C class information from the executable and attempts to print a warning, but this deadlocks everything as we hold the IO locks while completing arguments.

[aprantl]

Very nice!

include/lldb/Expression/ExpressionParser.h

52

Could you add a Doxygen comment?

source/Commands/CommandObjectExpression.cpp

332

Even if it is less efficient, a version of this using cmd.split(' ') or a loop over cmd.ltrim(' ') would probably be much shorter and potentially easier to read. There is also llvm::StringExtras::getToken().

391

Could you convert this to an early exit?

if (!target)
  return 0;

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

590

Should this perhaps use some form of StringRef::dropWhile or similar?
(https://llvm.org/doxygen/classllvm_1_1StringRef.html#aed7897c6ee084440516a7bb5e79a2094)

696

s/brackets/parentheses/

699

no need for curly braces here

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

172

Perhaps return an llvm::Error instead of an unsigned?

source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

629

You could also slice the StringRef at abs_pos, ::count('\n'), set column to slice.size-rfind('\n'). Your implementation is slightly faster, tough.

659

We don't typically put single statements in curly braces in LLVM coding style.

[labath]

I think this would be a very nice feature for lldb. Thank you for working on this.

However, I am somewhat worried about how you're hooking the expression completer into the completion machinery. I think this should be cleaned up first.

packages/Python/lldbsuite/test/functionalities/expr_completion/TestExprCompletion.py

1 ↗

(On Diff #152407)

Maybe put the test under the expression_command sub-tree?

177–215 ↗

(On Diff #152407)

I don't think a test like this has place in the test suite. It tests a different thing every time it's run and it will be impossible to debug if it starts to fail/be flaky on the build bots.

227 ↗

(On Diff #152407)

We normally use the unittest2 functions to do assertions (self.assertEquals(num_matches, 0))

246–264 ↗

(On Diff #152407)

We already have this function in TestCompletions.py. We should move it so some place that we can reuse it instead of reimplementing it.

packages/Python/lldbsuite/test/functionalities/expr_completion/main.cpp

1 ↗

(On Diff #152407)

The rest of this test is test is nicely self-contained. Could we avoid std::string here and make it fully hermetic?

source/Commands/CommandObjectExpression.cpp

418–422

Will this work correctly if the expression command contains arguments (expr -i0 -- my_expression)? What about quoted strings (expr "string with spaces<TAB>)?

Have you looked at whether it would be possible to refactor the completion api to provide the absolute position (it has to exist at some point), instead of trying to reverse-engineer it here?

I think the problem here is that the completion api has this built-in assumption that you're only ever going to be completing "parsed" commands, which is why you get the input as an Args array and a two-dimensional cursor position. "expr" command takes "raw" input, which means it does not go through the usual word-splitting and getopt parsing. You can see that because CommandObjectExpression::DoExecute takes a const char *command, whereas for "parsed" commands (e.g. "frame variable") the DoExecute function takes the argument as Args &command.

I think it would make sense to start this by refactoring the completion api to behave the same way as the "DoExecute" api. For "raw" commands , the HandleCompletion function would take a raw string + absolute position in that string, and the parsed commands would get the an Args array plus the two-dimensional position. Without that, you're going to get subtle differences in how the expression is treated for completion purposes and for actual evaluation.

[teemperor]

• Addresses the problems pointed out by Adrian and Pavel (Thanks!)
• Now using the completion API patch to get rid of the code that rebuilds the command line string from the args.

packages/Python/lldbsuite/test/functionalities/expr_completion/TestExprCompletion.py

177–215 ↗

(On Diff #152407)

I don't see how a seeded PRNG is flaky, but I think that test is also not important enough that I really want to push for merging it in. I just removed it.

source/Commands/CommandObjectExpression.cpp

418–422

I added another parent revision that gives us access to the raw command string, which removes all the cmd rebuilding code and fixes the cases you pointed out (which are now also in the test suite). I have to see how we can get rid of the string search for -- in both the completion/execute, but that's OOS.

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

590

Most of the functions are for working on the start of the string, but I don't see anything like dropWhile for the end of the string. There is not even a reverse find_if or something like that :(

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

172

Agreed. But I'll do that in a follow up revision because I didn't actually write the ParseInternal for this commit. It's just the renamed Parse function and added the missing documentation and completion parameters.

[teemperor]

Actually, because both @labath and @jingham requested refactoring to get rid of the -- search (even though Phabricator couldn't parse Jim's comment), I'll first also refactor this one. Thanks for the feedback!

[teemperor]

• Now using the new API for extracting the raw string from the option list.

[teemperor]

• Test case for completing when we only have a forward decl in another file (as suggested by Fred).

[teemperor]

• Resolved merge conflicts.

[teemperor]

Friendly ping on this (as the blockers for this patch are now all committed).

[jingham]

Yes, this is fine. Thanks for working on this!

[teemperor]

• Rebased patch.

[teemperor]

(Just pressing the green button for Jim)

include/lldb/Expression/ExpressionParser.h

ExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
                    bool generate_debug_info)
       : m_expr(expr), m_generate_debug_info(generate_debug_info) {}
 
   //------------------------------------------------------------------
   /// Destructor
   //------------------------------------------------------------------
   virtual ~ExpressionParser(){};
 
   //------------------------------------------------------------------
+  /// Attempts to find possible command line completions for the given
+  /// expression.
+  ///
+  /// @param[out] matches
+  ///     The list of completions that should be appended with string
+  ///     that would complete the current token at the cursor position.
+  ///     Note that the string in the list replaces the current token
+  ///     in the command line.
+  ///
+  /// @param[in] line
+  ///     The line with the completion cursor inside the expression as a string.
+  ///     The first line in the expression has the number 0.
+  ///
+  /// @param[in] pos
+  ///     The character position in the line with the completion cursor.
+  ///     If the value is 0, then the cursor is on top of the first character
+  ///     in the line (i.e. the user has requested completion from the start of
+  ///     the expression).
+  ///
+  /// @param[in] typed_pos
+  ///     The cursor position in the line as typed by the user. If the user
+  ///     expression has not been transformed in some form (e.g. wrapping it
+  ///     in a function body for C languages), then this is equal to the
+  ///     'pos' parameter. The semantics of this value are otherwise equal to
+  ///     'pos' (e.g. a value of 0 means the cursor is at start of the
+  ///     expression).
+  ///
+  /// @return
+  ///     True if we added any completion results to the output;
+  ///     false otherwise.
+  //------------------------------------------------------------------
+  virtual bool Complete(StringList &matches, unsigned line, unsigned pos,
+                        unsigned typed_pos) = 0;
+
+  //------------------------------------------------------------------
   /// Parse a single expression and convert it to IR using Clang.  Don't wrap
   /// the expression in anything at all.
   ///
   /// @param[in] diagnostic_manager
   ///     The diagnostic manager in which to store the errors and warnings.
   ///
   /// @return
   ///     The number of errors encountered during parsing.  0 means

include/lldb/Expression/UserExpression.h

public:
   /// @return
   ///     True on success (no errors); false otherwise.
   //------------------------------------------------------------------
   virtual bool Parse(DiagnosticManager &diagnostic_manager,
                      ExecutionContext &exe_ctx,
                      lldb_private::ExecutionPolicy execution_policy,
                      bool keep_result_in_memory, bool generate_debug_info) = 0;
 
+  //------------------------------------------------------------------
+  /// Attempts to find possible command line completions for the given
+  /// (possible incomplete) user expression.
+  ///
+  /// @param[in] exe_ctx
+  ///     The execution context to use when looking up entities that
+  ///     are needed for parsing and completing (locations of functions, types
+  ///     of variables, persistent variables, etc.)
+  ///
+  /// @param[out] matches
+  ///     The list of completions that should be appended with string
+  ///     that would complete the current token at the cursor position.
+  ///     Note that the string in the list replaces the current token
+  ///     in the command line.
+  ///
+  /// @param[in] complete_pos
+  ///     The position of the cursor inside the user expression string.
+  ///     The completion process starts on the token that the cursor is in.
+  ///
+  /// @return
+  ///     True if we added any completion results to the output;
+  ///     false otherwise.
+  //------------------------------------------------------------------
+  virtual bool Complete(ExecutionContext &exe_ctx, StringList &matches,
+                        unsigned complete_pos) {
+    return false;
+  }
+
   virtual bool CanInterpret() = 0;
 
   bool MatchesContext(ExecutionContext &exe_ctx);
 
   //------------------------------------------------------------------
   /// Execute the parsed expression by callinng the derived class's DoExecute
   /// method.
   ///

packages/Python/lldbsuite/test/expression_command/completion/.categories

+cmdline

packages/Python/lldbsuite/test/expression_command/completion/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/expression_command/completion/TestExprCompletion.py

+"""
+Test the lldb command line completion mechanism for the 'expr' command.
+"""
+
+from __future__ import print_function
+
+import random
+import os
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
+from lldbsuite.test import lldbutil
+
+class CommandLineExprCompletionTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
+    def test_expr_completion(self):
+        self.build()
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        # Try the completion before we have a context to complete on.
+        self.assume_no_completions('expr some_expr')
+        self.assume_no_completions('expr ')
+        self.assume_no_completions('expr f')
+
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                          '// Break here', self.main_source_spec)
+
+        # Completing member functions
+        self.complete_exactly('expr some_expr.FooNoArgs',
+                              'expr some_expr.FooNoArgsBar()')
+        self.complete_exactly('expr some_expr.FooWithArgs',
+                              'expr some_expr.FooWithArgsBar(')
+        self.complete_exactly('expr some_expr.FooWithMultipleArgs',
+                              'expr some_expr.FooWithMultipleArgsBar(')
+        self.complete_exactly('expr some_expr.FooUnderscore',
+                              'expr some_expr.FooUnderscoreBar_()')
+        self.complete_exactly('expr some_expr.FooNumbers',
+                              'expr some_expr.FooNumbersBar1()')
+        self.complete_exactly('expr some_expr.StaticMemberMethod',
+                              'expr some_expr.StaticMemberMethodBar()')
+
+        # Completing static functions
+        self.complete_exactly('expr Expr::StaticMemberMethod',
+                              'expr Expr::StaticMemberMethodBar()')
+
+        # Completing member variables
+        self.complete_exactly('expr some_expr.MemberVariab',
+                              'expr some_expr.MemberVariableBar')
+
+        # Multiple completions
+        self.completions_contain('expr some_expr.',
+                                 ['some_expr.FooNumbersBar1()',
+                                  'some_expr.FooUnderscoreBar_()',
+                                  'some_expr.FooWithArgsBar(',
+                                  'some_expr.MemberVariableBar'])
+
+        self.completions_contain('expr some_expr.Foo',
+                                 ['some_expr.FooNumbersBar1()',
+                                  'some_expr.FooUnderscoreBar_()',
+                                  'some_expr.FooWithArgsBar('])
+
+        self.completions_contain('expr ',
+                                 ['static_cast',
+                                  'reinterpret_cast',
+                                  'dynamic_cast'])
+
+        self.completions_contain('expr 1 + ',
+                                 ['static_cast',
+                                  'reinterpret_cast',
+                                  'dynamic_cast'])
+
+        # Completion expr without spaces
+        # This is a bit awkward looking for the user, but that's how
+        # the completion API works at the moment.
+        self.completions_contain('expr 1+',
+                                 ['1+some_expr', "1+static_cast"])
+
+        # Test with spaces
+        self.complete_exactly('expr   some_expr .FooNoArgs',
+                              'expr   some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr  some_expr .FooNoArgs',
+                              'expr  some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr some_expr .FooNoArgs',
+                              'expr some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr some_expr. FooNoArgs',
+                              'expr some_expr. FooNoArgsBar()')
+        self.complete_exactly('expr some_expr . FooNoArgs',
+                              'expr some_expr . FooNoArgsBar()')
+        self.complete_exactly('expr Expr :: StaticMemberMethod',
+                              'expr Expr :: StaticMemberMethodBar()')
+        self.complete_exactly('expr Expr ::StaticMemberMethod',
+                              'expr Expr ::StaticMemberMethodBar()')
+        self.complete_exactly('expr Expr:: StaticMemberMethod',
+                              'expr Expr:: StaticMemberMethodBar()')
+
+        # Test that string literals don't break our parsing logic.
+        self.complete_exactly('expr const char *cstr = "some_e"; char c = *cst',
+                              'expr const char *cstr = "some_e"; char c = *cstr')
+        self.complete_exactly('expr const char *cstr = "some_e" ; char c = *cst',
+                              'expr const char *cstr = "some_e" ; char c = *cstr')
+        # Requesting completions inside an incomplete string doesn't provide any
+        # completions.
+        self.complete_exactly('expr const char *cstr = "some_e',
+                              'expr const char *cstr = "some_e')
+
+        # Test with expr arguments
+        self.complete_exactly('expr -i0 -- some_expr .FooNoArgs',
+                              'expr -i0 -- some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr  -i0 -- some_expr .FooNoArgs',
+                              'expr  -i0 -- some_expr .FooNoArgsBar()')
+
+        # Addrof and deref
+        self.complete_exactly('expr (*(&some_expr)).FooNoArgs',
+                              'expr (*(&some_expr)).FooNoArgsBar()')
+        self.complete_exactly('expr (*(&some_expr)) .FooNoArgs',
+                              'expr (*(&some_expr)) .FooNoArgsBar()')
+        self.complete_exactly('expr (* (&some_expr)) .FooNoArgs',
+                              'expr (* (&some_expr)) .FooNoArgsBar()')
+        self.complete_exactly('expr (* (& some_expr)) .FooNoArgs',
+                              'expr (* (& some_expr)) .FooNoArgsBar()')
+
+        # Addrof and deref (part 2)
+        self.complete_exactly('expr (&some_expr)->FooNoArgs',
+                              'expr (&some_expr)->FooNoArgsBar()')
+        self.complete_exactly('expr (&some_expr) ->FooNoArgs',
+                              'expr (&some_expr) ->FooNoArgsBar()')
+        self.complete_exactly('expr (&some_expr) -> FooNoArgs',
+                              'expr (&some_expr) -> FooNoArgsBar()')
+        self.complete_exactly('expr (&some_expr)-> FooNoArgs',
+                              'expr (&some_expr)-> FooNoArgsBar()')
+
+        # Builtin arg
+        self.complete_exactly('expr static_ca',
+                              'expr static_cast')
+
+        # Types
+        self.complete_exactly('expr LongClassNa',
+                              'expr LongClassName')
+        self.complete_exactly('expr LongNamespaceName::NestedCla',
+                              'expr LongNamespaceName::NestedClass')
+
+        # Namespaces
+        self.complete_exactly('expr LongNamespaceNa',
+                              'expr LongNamespaceName::')
+
+        # Multiple arguments
+        self.complete_exactly('expr &some_expr + &some_e',
+                              'expr &some_expr + &some_expr')
+        self.complete_exactly('expr SomeLongVarNameWithCapitals + SomeLongVarName',
+                              'expr SomeLongVarNameWithCapitals + SomeLongVarNameWithCapitals')
+        self.complete_exactly('expr SomeIntVar + SomeIntV',
+                              'expr SomeIntVar + SomeIntVar')
+
+        # Multiple statements
+        self.complete_exactly('expr long LocalVariable = 0; LocalVaria',
+                              'expr long LocalVariable = 0; LocalVariable')
+
+        # Custom Decls
+        self.complete_exactly('expr auto l = [](int LeftHandSide, int bx){ return LeftHandS',
+                              'expr auto l = [](int LeftHandSide, int bx){ return LeftHandSide')
+        self.complete_exactly('expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.Mem',
+                              'expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.MemberName')
+
+        # Completing function call arguments
+        self.complete_exactly('expr some_expr.FooWithArgsBar(some_exp',
+                              'expr some_expr.FooWithArgsBar(some_expr')
+        self.complete_exactly('expr some_expr.FooWithArgsBar(SomeIntV',
+                              'expr some_expr.FooWithArgsBar(SomeIntVar')
+        self.complete_exactly('expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVa',
+                              'expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVar')
+
+        # Function return values
+        self.complete_exactly('expr some_expr.Self().FooNoArgs',
+                              'expr some_expr.Self().FooNoArgsBar()')
+        self.complete_exactly('expr some_expr.Self() .FooNoArgs',
+                              'expr some_expr.Self() .FooNoArgsBar()')
+        self.complete_exactly('expr some_expr.Self(). FooNoArgs',
+                              'expr some_expr.Self(). FooNoArgsBar()')
+
+    def assume_no_completions(self, str_input):
+        interp = self.dbg.GetCommandInterpreter()
+        match_strings = lldb.SBStringList()
+        num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
+
+        available_completions = []
+        for m in match_strings:
+            available_completions.append(m)
+
+        self.assertEquals(num_matches, 0, "Got matches, but didn't expect any: " + str(available_completions))
+
+    def completions_contain(self, str_input, items):
+        interp = self.dbg.GetCommandInterpreter()
+        match_strings = lldb.SBStringList()
+        num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
+        common_match = match_strings.GetStringAtIndex(0)
+
+        for item in items:
+            found = False
+            for m in match_strings:
+                if m == item:
+                    found = True
+            if not found:
+                # Transform match_strings to a python list with strings
+                available_completions = []
+                for m in match_strings:
+                     available_completions.append(m)
+                self.assertTrue(found, "Couldn't find completion " + item + " in completions " + str(available_completions))

packages/Python/lldbsuite/test/expression_command/completion/main.cpp

+namespace LongNamespaceName { class NestedClass { long m; }; }
+
+class LongClassName { long i ; };
+
+class Expr {
+public:
+    int FooNoArgsBar() { return 1; }
+    int FooWithArgsBar(int i) { return i; }
+    int FooWithMultipleArgsBar(int i, int j) { return i + j; }
+    int FooUnderscoreBar_() { return 4; }
+    int FooNumbersBar1() { return 8; }
+    int MemberVariableBar = 0;
+    Expr &Self() { return *this; }
+    static int StaticMemberMethodBar() { return 82; }
+};
+
+int main()
+{
+    LongClassName a;
+    LongNamespaceName::NestedClass NestedFoo;
+    long SomeLongVarNameWithCapitals = 44;
+    int SomeIntVar = 33;
+    Expr some_expr;
+    some_expr.FooNoArgsBar();
+    some_expr.FooWithArgsBar(1);
+    some_expr.FooUnderscoreBar_();
+    some_expr.FooNumbersBar1();
+    Expr::StaticMemberMethodBar();
+    return 0; // Break here
+}

packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

class CommandLineCompletionTestCase(TestBase):
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_symbol_name(self):
         self.build()
         self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.complete_from_to('breakpoint set -n Fo',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
-
-    def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
-        """Test that the completion mechanism completes str_input to patterns,
-        where patterns could be a pattern-string or a list of pattern-strings"""
-        # Patterns should not be None in order to proceed.
-        self.assertFalse(patterns is None)
-        # And should be either a string or list of strings.  Check for list type
-        # below, if not, make a list out of the singleton string.  If patterns
-        # is not a string or not a list of strings, there'll be runtime errors
-        # later on.
-        if not isinstance(patterns, list):
-            patterns = [patterns]
-
-        interp = self.dbg.GetCommandInterpreter()
-        match_strings = lldb.SBStringList()
-        num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
-        common_match = match_strings.GetStringAtIndex(0)
-        if num_matches == 0:
-            compare_string = str_input
-        else: 
-            if common_match != None and len(common_match) > 0:
-                compare_string = str_input + common_match
-            else:
-                compare_string = ""
-                for idx in range(1, num_matches+1):
-                    compare_string += match_strings.GetStringAtIndex(idx) + "\n"
-
-        for p in patterns:
-            if turn_off_re_match:
-                self.expect(
-                    compare_string, msg=COMPLETION_MSG(
-                        str_input, p), exe=False, substrs=[p])
-            else:
-                self.expect(
-                    compare_string, msg=COMPLETION_MSG(
-                        str_input, p), exe=False, patterns=[p])

packages/Python/lldbsuite/test/lldbtest.py

 WATCHPOINT_CREATED = "Watchpoint created successfully"
 
 
 def CMD_MSG(str):
     '''A generic "Command '%s' returns successfully" message generator.'''
     return "Command '%s' returns successfully" % str
 
 
-def COMPLETION_MSG(str_before, str_after):
+def COMPLETION_MSG(str_before, str_after, str_got=None):
     '''A generic message generator for the completion mechanism.'''
+    if str_got != None:
+        return "'%s' successfully completes to '%s' instead of '%s'" % (str_before, str_after, str_got)
+    else:
         return "'%s' successfully completes to '%s'" % (str_before, str_after)
 
 
 def EXP_MSG(str, actual, exe):
     '''A generic "'%s' returns expected result" message generator if exe.
     Otherwise, it generates "'%s' matches expected result" message.'''
 
     return "'%s' %s expected result, got '%s'" % (
         str, 'returns' if exe else 'matches', actual.strip())
def match(
             if matched:
                 break
 
         self.assertTrue(matched if matching else not matched,
                         msg if msg else EXP_MSG(str, output, exe))
 
         return match_object
 
+
+    def complete_exactly(self, str_input, patterns):
+        self.complete_from_to(str_input, patterns, True)
+
+    def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
+        """Test that the completion mechanism completes str_input to patterns,
+        where patterns could be a pattern-string or a list of pattern-strings"""
+        # Patterns should not be None in order to proceed.
+        self.assertFalse(patterns is None)
+        # And should be either a string or list of strings.  Check for list type
+        # below, if not, make a list out of the singleton string.  If patterns
+        # is not a string or not a list of strings, there'll be runtime errors
+        # later on.
+        if not isinstance(patterns, list):
+            patterns = [patterns]
+
+        interp = self.dbg.GetCommandInterpreter()
+        match_strings = lldb.SBStringList()
+        num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
+        common_match = match_strings.GetStringAtIndex(0)
+        if num_matches == 0:
+            compare_string = str_input
+        else:
+            if common_match != None and len(common_match) > 0:
+                compare_string = str_input + common_match
+            else:
+                compare_string = ""
+                for idx in range(1, num_matches+1):
+                    compare_string += match_strings.GetStringAtIndex(idx) + "\n"
+
+        for p in patterns:
+            if turn_off_re_match:
+                self.expect(
+                    compare_string, msg=COMPLETION_MSG(
+                        str_input, p), exe=False, substrs=[p])
+            else:
+                self.expect(
+                    compare_string, msg=COMPLETION_MSG(
+                        str_input, p), exe=False, patterns=[p])
+
     def expect(
             self,
             str,
             msg=None,
             patterns=None,
             startstr=None,
             endstr=None,
             substrs=None,

source/Commands/CommandObjectExpression.h

public:
   };
 
   CommandObjectExpression(CommandInterpreter &interpreter);
 
   ~CommandObjectExpression() override;
 
   Options *GetOptions() override;
 
+  int HandleCompletion(CompletionRequest &request) override;
+
 protected:
   //------------------------------------------------------------------
   // IOHandler::Delegate functions
   //------------------------------------------------------------------
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
 
   bool IOHandlerIsInputComplete(IOHandler &io_handler,

source/Commands/CommandObjectExpression.cpp

Examples:
   m_option_group.Append(&m_repl_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_3);
   m_option_group.Finalize();
 }
 
 CommandObjectExpression::~CommandObjectExpression() = default;
 
 Options *CommandObjectExpression::GetOptions() { return &m_option_group; }
 
+int CommandObjectExpression::HandleCompletion(CompletionRequest &request) {
+  EvaluateExpressionOptions options;
+  options.SetCoerceToId(m_varobj_options.use_objc);
+  options.SetLanguage(m_command_options.language);
+  options.SetExecutionPolicy(lldb_private::eExecutionPolicyNever);
+  options.SetAutoApplyFixIts(false);
+  options.SetGenerateDebugInfo(false);
+
+  // We need a valid execution context with a frame pointer for this
+  // completion, so if we don't have one we should try to make a valid
+  // execution context.
+  if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
+    m_interpreter.UpdateExecutionContext(nullptr);
+
+  // This didn't work, so let's get out before we start doing things that
+  // expect a valid frame pointer.
+  if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr)
+    return 0;
+
+  ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
+
+  Target *target = exe_ctx.GetTargetPtr();
+
+  if (!target)
+    target = GetDummyTarget();
+
+  if (!target)
+    return 0;
+
+  unsigned cursor_pos = request.GetRawCursorPos();
+  llvm::StringRef code = request.GetRawLine();
+
+  // Remove the first token which is 'expr' or some alias/abbreviation of that.
+  const std::size_t old_code_size = code.size();
+  code = llvm::getToken(code).second.ltrim();
+
+  // We have an option, so we skip behind those options by looking for "--".
+  if (code.startswith("-")) {
+    // Skip all arguments.
+    llvm::StringRef arg_separator = "--";
+    std::size_t separator_pos = code.find(arg_separator);
+    if (separator_pos != llvm::StringRef::npos) {
+      code = code.substr(separator_pos + arg_separator.size());
+    }
+  }
+
+  // Make the cursor_pos again relative to the start of the code string.
+  cursor_pos -= (old_code_size - code.size());
+  // Drop trailing code, as we anyway don't use it for completion.
+  code = code.substr(0, cursor_pos);
+
+  auto language = exe_ctx.GetFrameRef().GetLanguage();
+
+  Status error;
+  lldb::UserExpressionSP expr(target->GetUserExpressionForLanguage(
+      code, llvm::StringRef(), language, UserExpression::eResultTypeAny,
+      options, error));
+  if (error.Fail())
+    return 0;
+
+  expr->Complete(exe_ctx, request.GetMatches(), cursor_pos);
+  return request.GetMatches().GetSize();
+}
+
 static lldb_private::Status
 CanBeUsedForElementCountPrinting(ValueObject &valobj) {
   CompilerType type(valobj.GetCompilerType());
   CompilerType pointee;
   if (!type.IsPointerType(&pointee))
     return Status("as it does not refer to a pointer");
   if (pointee.IsVoidType())
     return Status("as it refers to a pointer to void");
   return Status();
 }
 
 bool CommandObjectExpression::EvaluateExpression(const char *expr,
                                                  Stream *output_stream,
                                                  Stream *error_stream,
                                                  CommandReturnObject *result) {
   // Don't use m_exe_ctx as this might be called asynchronously after the
   // command object DoExecute has finished when doing multi-line expression
   // that use an input reader...
   ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
 
   Target *target = exe_ctx.GetTargetPtr();
 
   if (!target)
     target = GetDummyTarget();
 
   if (target) {
if (target) {
     options.SetTryAllThreads(m_command_options.try_all_threads);
     options.SetDebug(m_command_options.debug);
     options.SetLanguage(m_command_options.language);
     options.SetExecutionPolicy(
         m_command_options.allow_jit
             ? EvaluateExpressionOptions::default_execution_policy
             : lldb_private::eExecutionPolicyNever);
 
     bool auto_apply_fixits;
     if (m_command_options.auto_apply_fixits == eLazyBoolCalculate)
       auto_apply_fixits = target->GetEnableAutoApplyFixIts();
     else
       auto_apply_fixits =
           m_command_options.auto_apply_fixits == eLazyBoolYes ? true : false;
 
     options.SetAutoApplyFixIts(auto_apply_fixits);
 
     if (m_command_options.top_level)
       options.SetExecutionPolicy(eExecutionPolicyTopLevel);
 
     // If there is any chance we are going to stop and want to see what went

source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

void ASTResultSynthesizer::TransformTopLevelDecl(Decl *D) {
   } else if (!m_top_level) {
     if (ObjCMethodDecl *method_decl = dyn_cast<ObjCMethodDecl>(D)) {
       if (m_ast_context &&
           !method_decl->getSelector().getAsString().compare("$__lldb_expr:")) {
         RecordPersistentTypes(method_decl);
         SynthesizeObjCMethodResult(method_decl);
       }
     } else if (FunctionDecl *function_decl = dyn_cast<FunctionDecl>(D)) {
-      if (m_ast_context &&
+      // When completing user input the body of the function may be a nullptr.
+      if (m_ast_context && function_decl->hasBody() &&
           !function_decl->getNameInfo().getAsString().compare("$__lldb_expr")) {
         RecordPersistentTypes(function_decl);
         SynthesizeFunctionResult(function_decl);
       }
     }
   }
 }
 

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

 #include "lldb/Expression/ExpressionParser.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-public.h"
 
 #include <string>
 #include <vector>
 
+namespace clang {
+class CodeCompleteConsumer;
+}
+
 namespace lldb_private {
 
 class IRExecutionUnit;
 
 //----------------------------------------------------------------------
 /// @class ClangExpressionParser ClangExpressionParser.h
 /// "lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of
 /// Clang that can parse expressions.
public:
   ClangExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
                         bool generate_debug_info);
 
   //------------------------------------------------------------------
   /// Destructor
   //------------------------------------------------------------------
   ~ClangExpressionParser() override;
 
+  bool Complete(StringList &matches, unsigned line, unsigned pos,
+                unsigned typed_pos) override;
+
   //------------------------------------------------------------------
   /// Parse a single expression and convert it to IR using Clang.  Don't wrap
   /// the expression in anything at all.
   ///
   /// @param[in] diagnostic_manager
   ///     The diagnostic manager to report errors to.
   ///
   /// @return
public:
   ///     The target architecture.
   ///
   /// @return
   ///     A string representing target ABI for the current architecture.
   //-------------------------------------------------------------------
   std::string GetClangTargetABI(const ArchSpec &target_arch);
 
 private:
+  //------------------------------------------------------------------
+  /// Parses the expression.
+  ///
+  /// @param[in] diagnostic_manager
+  ///     The diagnostic manager that should receive the diagnostics
+  ///     from the parsing process.
+  ///
+  /// @param[in] completion
+  ///     The completion consumer that should be used during parsing
+  ///     (or a nullptr if no consumer should be attached).
+  ///
+  /// @param[in] completion_line
+  ///     The line in which the completion marker should be placed.
+  ///     The first line is represented by the value 0.
+  ///
+  /// @param[in] completion_column
+  ///     The column in which the completion marker should be placed.
+  ///     The first column is represented by the value 0.
+  ///
+  /// @return
+  ///    The number of parsing errors.
+  //-------------------------------------------------------------------
+  unsigned ParseInternal(DiagnosticManager &diagnostic_manager,
+                         clang::CodeCompleteConsumer *completion = nullptr,
+                         unsigned completion_line = 0,
+                         unsigned completion_column = 0);
+
   std::unique_ptr<llvm::LLVMContext>
       m_llvm_context; ///< The LLVM context to generate IR into
   std::unique_ptr<clang::FileManager>
       m_file_manager; ///< The Clang file manager object used by the compiler
   std::unique_ptr<clang::CompilerInstance>
       m_compiler; ///< The Clang compiler used to parse expressions into IR
   std::unique_ptr<clang::Builtin::Context>
       m_builtin_context; ///< Context for Clang built-ins

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
+#include "clang/Sema/CodeCompleteConsumer.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TargetSelect.h"
 
ClangExpressionParser::ClangExpressionParser(ExecutionContextScope *exe_scope,
   m_code_generator.reset(CreateLLVMCodeGen(
       m_compiler->getDiagnostics(), module_name,
       m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(),
       m_compiler->getCodeGenOpts(), *m_llvm_context));
 }
 
 ClangExpressionParser::~ClangExpressionParser() {}
 
+namespace {
+
+//----------------------------------------------------------------------
+/// @class CodeComplete
+///
+/// A code completion consumer for the clang Sema that is responsible for
+/// creating the completion suggestions when a user requests completion
+/// of an incomplete `expr` invocation.
+//----------------------------------------------------------------------
+class CodeComplete : public CodeCompleteConsumer {
+  CodeCompletionTUInfo CCTUInfo;
+
+  std::string expr;
+  unsigned position = 0;
+  StringList &matches;
+
+  /// Returns true if the given character can be used in an identifier.
+  /// This also returns true for numbers because for completion we usually
+  /// just iterate backwards over iterators.
+  ///
+  /// Note: lldb uses '$' in its internal identifiers, so we also allow this.
+  static bool IsIdChar(char c) {
+    return c == '_' || std::isalnum(c) || c == '$';
+  }
+
+  /// Returns true if the given character is used to separate arguments
+  /// in the command line of lldb.
+  static bool IsTokenSeparator(char c) { return c == ' ' || c == '\t'; }
+
+  /// Drops all tokens in front of the expression that are unrelated for
+  /// the completion of the cmd line. 'unrelated' means here that the token
+  /// is not interested for the lldb completion API result.
+  StringRef dropUnrelatedFrontTokens(StringRef cmd) {
+    if (cmd.empty())
+      return cmd;
+
+    // If we are at the start of a word, then all tokens are unrelated to
+    // the current completion logic.
+    if (IsTokenSeparator(cmd.back()))
+      return StringRef();
+
+    // Remove all previous tokens from the string as they are unrelated
+    // to completing the current token.
+    StringRef to_remove = cmd;
+    while (!to_remove.empty() && !IsTokenSeparator(to_remove.back())) {
+      to_remove = to_remove.drop_back();
+    }
+    cmd = cmd.drop_front(to_remove.size());
+
+    return cmd;
+  }
+
+  /// Removes the last identifier token from the given cmd line.
+  StringRef removeLastToken(StringRef cmd) {
+    while (!cmd.empty() && IsIdChar(cmd.back())) {
+      cmd = cmd.drop_back();
+    }
+    return cmd;
+  }
+
+  /// Attemps to merge the given completion from the given position into the
+  /// existing command. Returns the completion string that can be returned to
+  /// the lldb completion API.
+  std::string mergeCompletion(StringRef existing, unsigned pos,
+                              StringRef completion) {
+    StringRef existing_command = existing.substr(0, pos);
+    // We rewrite the last token with the completion, so let's drop that
+    // token from the command.
+    existing_command = removeLastToken(existing_command);
+    // We also should remove all previous tokens from the command as they
+    // would otherwise be added to the completion that already has the
+    // completion.
+    existing_command = dropUnrelatedFrontTokens(existing_command);
+    return existing_command.str() + completion.str();
+  }
+
+public:
+  /// Constructs a CodeComplete consumer that can be attached to a Sema.
+  /// @param[out] matches
+  ///    The list of matches that the lldb completion API expects as a result.
+  ///    This may already contain matches, so it's only allowed to append
+  ///    to this variable.
+  /// @param[out] expr
+  ///    The whole expression string that we are currently parsing. This
+  ///    string needs to be equal to the input the user typed, and NOT the
+  ///    final code that Clang is parsing.
+  /// @param[out] position
+  ///    The character position of the user cursor in the `expr` parameter.
+  ///
+  CodeComplete(StringList &matches, std::string expr, unsigned position)
+      : CodeCompleteConsumer(CodeCompleteOptions(), false),
+        CCTUInfo(std::make_shared<GlobalCodeCompletionAllocator>()), expr(expr),
+        position(position), matches(matches) {}
+
+  /// Deregisters and destroys this code-completion consumer.
+  virtual ~CodeComplete() {}
+
+  /// \name Code-completion filtering
+  /// Check if the result should be filtered out.
+  bool isResultFilteredOut(StringRef Filter,
+                           CodeCompletionResult Result) override {
+    // This code is mostly copied from CodeCompleteConsumer.
+    switch (Result.Kind) {
+    case CodeCompletionResult::RK_Declaration:
+      return !(
+          Result.Declaration->getIdentifier() &&
+          Result.Declaration->getIdentifier()->getName().startswith(Filter));
+    case CodeCompletionResult::RK_Keyword:
+      return !StringRef(Result.Keyword).startswith(Filter);
+    case CodeCompletionResult::RK_Macro:
+      return !Result.Macro->getName().startswith(Filter);
+    case CodeCompletionResult::RK_Pattern:
+      return !StringRef(Result.Pattern->getAsString()).startswith(Filter);
+    }
+    // If we trigger this assert or the above switch yields a warning, then
+    // CodeCompletionResult has been enhanced with more kinds of completion
+    // results. Expand the switch above in this case.
+    assert(false && "Unknown completion result type?");
+    // If we reach this, then we should just ignore whatever kind of unknown
+    // result we got back. We probably can't turn it into any kind of useful
+    // completion suggestion with the existing code.
+    return true;
+  }
+
+  /// \name Code-completion callbacks
+  /// Process the finalized code-completion results.
+  void ProcessCodeCompleteResults(Sema &SemaRef, CodeCompletionContext Context,
+                                  CodeCompletionResult *Results,
+                                  unsigned NumResults) override {
+
+    // The Sema put the incomplete token we try to complete in here during
+    // lexing, so we need to retrieve it here to know what we are completing.
+    StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
+
+    // Iterate over all the results. Filter out results we don't want and
+    // process the rest.
+    for (unsigned I = 0; I != NumResults; ++I) {
+      // Filter the results with the information from the Sema.
+      if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
+        continue;
+
+      CodeCompletionResult &R = Results[I];
+      std::string ToInsert;
+      // Handle the different completion kinds that come from the Sema.
+      switch (R.Kind) {
+      case CodeCompletionResult::RK_Declaration: {
+        const NamedDecl *D = R.Declaration;
+        ToInsert = R.Declaration->getNameAsString();
+        // If we have a function decl that has no arguments we want to
+        // complete the empty parantheses for the user. If the function has
+        // arguments, we at least complete the opening bracket.
+        if (const FunctionDecl *F = dyn_cast<FunctionDecl>(D)) {
+          if (F->getNumParams() == 0)
+            ToInsert += "()";
+          else
+            ToInsert += "(";
+        }
+        // If we try to complete a namespace, then we directly can append
+        // the '::'.
+        if (const NamespaceDecl *N = dyn_cast<NamespaceDecl>(D)) {
+          if (!N->isAnonymousNamespace())
+            ToInsert += "::";
+        }
+        break;
+      }
+      case CodeCompletionResult::RK_Keyword:
+        ToInsert = R.Keyword;
+        break;
+      case CodeCompletionResult::RK_Macro:
+        // It's not clear if we want to complete any macros in the
+        ToInsert = R.Macro->getName().str();
+        break;
+      case CodeCompletionResult::RK_Pattern:
+        ToInsert = R.Pattern->getTypedText();
+        break;
+      }
+      // At this point all information is in the ToInsert string.
+
+      // We also filter some internal lldb identifiers here. The user
+      // shouldn't see these.
+      if (StringRef(ToInsert).startswith("$__lldb_"))
+        continue;
+      if (!ToInsert.empty()) {
+        // Merge the suggested Token into the existing command line to comply
+        // with the kind of result the lldb API expects.
+        std::string CompletionSuggestion =
+            mergeCompletion(expr, position, ToInsert);
+        matches.AppendString(CompletionSuggestion);
+      }
+    }
+  }
+
+  /// \param S the semantic-analyzer object for which code-completion is being
+  /// done.
+  ///
+  /// \param CurrentArg the index of the current argument.
+  ///
+  /// \param Candidates an array of overload candidates.
+  ///
+  /// \param NumCandidates the number of overload candidates
+  void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
+                                 OverloadCandidate *Candidates,
+                                 unsigned NumCandidates) override {
+    // At the moment we don't filter out any overloaded candidates.
+  }
+
+  CodeCompletionAllocator &getAllocator() override {
+    return CCTUInfo.getAllocator();
+  }
+
+  CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
+};
+} // namespace
+
+bool ClangExpressionParser::Complete(StringList &matches, unsigned line,
+                                     unsigned pos, unsigned typed_pos) {
+  DiagnosticManager mgr;
+  // We need the raw user expression here because that's what the CodeComplete
+  // class uses to provide completion suggestions.
+  // However, the `Text` method only gives us the transformed expression here.
+  // To actually get the raw user input here, we have to cast our expression to
+  // the LLVMUserExpression which exposes the right API. This should never fail
+  // as we always have a ClangUserExpression whenever we call this.
+  LLVMUserExpression &llvm_expr = *static_cast<LLVMUserExpression *>(&m_expr);
+  CodeComplete CC(matches, llvm_expr.GetUserText(), typed_pos);
+  // We don't need a code generator for parsing.
+  m_code_generator.reset();
+  // Start parsing the expression with our custom code completion consumer.
+  ParseInternal(mgr, &CC, line, pos);
+  return true;
+}
+
 unsigned ClangExpressionParser::Parse(DiagnosticManager &diagnostic_manager) {
+  return ParseInternal(diagnostic_manager);
+}
+
+unsigned
+ClangExpressionParser::ParseInternal(DiagnosticManager &diagnostic_manager,
+                                     CodeCompleteConsumer *completion_consumer,
+                                     unsigned completion_line,
+                                     unsigned completion_column) {
   ClangDiagnosticManagerAdapter *adapter =
       static_cast<ClangDiagnosticManagerAdapter *>(
           m_compiler->getDiagnostics().getClient());
   clang::TextDiagnosticBuffer *diag_buf = adapter->GetPassthrough();
   diag_buf->FlushDiagnostics(m_compiler->getDiagnostics());
 
   adapter->ResetManager(&diagnostic_manager);
 
   const char *expr_text = m_expr.Text();
 
   clang::SourceManager &source_mgr = m_compiler->getSourceManager();
   bool created_main_file = false;
-  if (m_compiler->getCodeGenOpts().getDebugInfo() ==
-      codegenoptions::FullDebugInfo) {
+
+  // Clang wants to do completion on a real file known by Clang's file manager,
+  // so we have to create one to make this work.
+  // TODO: We probably could also simulate to Clang's file manager that there
+  // is a real file that contains our code.
+  bool should_create_file = completion_consumer != nullptr;
+
+  // We also want a real file on disk if we generate full debug info.
+  should_create_file |= m_compiler->getCodeGenOpts().getDebugInfo() ==
+                        codegenoptions::FullDebugInfo;
+
+  if (should_create_file) {
     int temp_fd = -1;
     llvm::SmallString<PATH_MAX> result_path;
     if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
       tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr");
       std::string temp_source_path = tmpdir_file_spec.GetPath();
       llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path);
     } else {
       llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
ClangExpressionHelper *type_system_helper =
       dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
 
   ASTConsumer *ast_transformer =
       type_system_helper->ASTTransformer(m_code_generator.get());
 
   if (ClangExpressionDeclMap *decl_map = type_system_helper->DeclMap())
     decl_map->InstallCodeGenerator(m_code_generator.get());
 
+  // If we want to parse for code completion, we need to attach our code
+  // completion consumer to the Sema and specify a completion position.
+  // While parsing the Sema will call this consumer with the provided
+  // completion suggestions.
+  if (completion_consumer) {
+    auto main_file = source_mgr.getFileEntryForID(source_mgr.getMainFileID());
+    auto &PP = m_compiler->getPreprocessor();
+    // Lines and columns start at 1 in Clang, but code completion positions are
+    // indexed from 0, so we need to add 1 to the line and column here.
+    ++completion_line;
+    ++completion_column;
+    PP.SetCodeCompletionPoint(main_file, completion_line, completion_column);
+  }
+
   if (ast_transformer) {
     ast_transformer->Initialize(m_compiler->getASTContext());
     ParseAST(m_compiler->getPreprocessor(), ast_transformer,
-             m_compiler->getASTContext());
+             m_compiler->getASTContext(), false, TU_Complete,
+             completion_consumer);
   } else {
     m_code_generator->Initialize(m_compiler->getASTContext());
     ParseAST(m_compiler->getPreprocessor(), m_code_generator.get(),
-             m_compiler->getASTContext());
+             m_compiler->getASTContext(), false, TU_Complete,
+             completion_consumer);
   }
 
   diag_buf->EndSourceFile();
 
   unsigned num_errors = diag_buf->getNumErrors();
 
   if (m_pp_callbacks && m_pp_callbacks->hasErrors()) {
     num_errors++;

source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

public:
   ///
   /// @return
   ///     True on success (no errors); false otherwise.
   //------------------------------------------------------------------
   bool Parse(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
              lldb_private::ExecutionPolicy execution_policy,
              bool keep_result_in_memory, bool generate_debug_info) override;
 
+  bool Complete(ExecutionContext &exe_ctx, StringList &matches,
+                unsigned complete_pos) override;
+
   ExpressionTypeSystemHelper *GetTypeSystemHelper() override {
     return &m_type_system_helper;
   }
 
   ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); }
 
   void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); }
 
public:
     lldb::ExpressionVariableSP &GetVariable();
 
   private:
     PersistentExpressionState *m_persistent_state;
     lldb::ExpressionVariableSP m_variable;
     lldb::TargetSP m_target_sp;
   };
 
+  /// The absolute character position in the transformed source code where the
+  /// user code (as typed by the user) starts. If the variable is empty, then we
+  /// were not able to calculate this position.
+  llvm::Optional<unsigned> m_user_expression_start_pos;
   ResultDelegate m_result_delegate;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangUserExpression_h_

source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

else
       lang_type = lldb::eLanguageTypeC;
 
     if (!source_code->GetText(m_transformed_text, lang_type, m_in_static_method,
                               exe_ctx)) {
       diagnostic_manager.PutString(eDiagnosticSeverityError,
                                    "couldn't construct expression body");
       return llvm::Optional<lldb::LanguageType>();
     }
+
+    // Find and store the start position of the original code inside the
+    // transformed code. We need this later for the code completion.
+    std::size_t original_start;
+    std::size_t original_end;
+    bool found_bounds = source_code->GetOriginalBodyBounds(
+        m_transformed_text, lang_type, original_start, original_end);
+    if (found_bounds) {
+      m_user_expression_start_pos = original_start;
+    }
   }
   return lang_type;
 }
 
 bool ClangUserExpression::PrepareForParsing(
     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx) {
   InstallContext(exe_ctx);
 
if (generate_debug_info) {
     }
   }
 
   if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
     m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
   return true;
 }
 
+//------------------------------------------------------------------
+/// Converts an absolute position inside a given code string into
+/// a column/line pair.
+///
+/// @param[in] abs_pos
+///     A absolute position in the code string that we want to convert
+///     to a column/line pair.
+///
+/// @param[in] code
+///     A multi-line string usually representing source code.
+///
+/// @param[out] line
+///     The line in the code that contains the given absolute position.
+///     The first line in the string is indexed as 1.
+///
+/// @param[out] column
+///     The column in the line that contains the absolute position.
+///     The first character in a line is indexed as 0.
+//------------------------------------------------------------------
+static void AbsPosToLineColumnPos(unsigned abs_pos, llvm::StringRef code,
+                                  unsigned &line, unsigned &column) {
+  // Reset to code position to beginning of the file.
+  line = 0;
+  column = 0;
+
+  assert(abs_pos <= code.size() && "Absolute position outside code string?");
+
+  // We have to walk up to the position and count lines/columns.
+  for (std::size_t i = 0; i < abs_pos; ++i) {
+    // If we hit a line break, we go back to column 0 and enter a new line.
+    // We only handle \n because that's what we internally use to make new
+    // lines for our temporary code strings.
+    if (code[i] == '\n') {
+      ++line;
+      column = 0;
+      continue;
+    }
+    ++column;
+  }
+}
+
+bool ClangUserExpression::Complete(ExecutionContext &exe_ctx,
+                                   StringList &matches, unsigned complete_pos) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  // We don't want any visible feedback when completing an expression. Mostly
+  // because the results we get from an incomplete invocation are probably not
+  // correct.
+  DiagnosticManager diagnostic_manager;
+
+  if (!PrepareForParsing(diagnostic_manager, exe_ctx))
+    return false;
+
+  lldb::LanguageType lang_type = lldb::LanguageType::eLanguageTypeUnknown;
+  if (auto new_lang = GetLanguageForExpr(diagnostic_manager, exe_ctx))
+    lang_type = new_lang.getValue();
+
+  if (log)
+    log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str());
+
+  //////////////////////////
+  // Parse the expression
+  //
+
+  m_materializer_ap.reset(new Materializer());
+
+  ResetDeclMap(exe_ctx, m_result_delegate, /*keep result in memory*/ true);
+
+  OnExit on_exit([this]() { ResetDeclMap(); });
+
+  if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get())) {
+    diagnostic_manager.PutString(
+        eDiagnosticSeverityError,
+        "current process state is unsuitable for expression parsing");
+
+    return false;
+  }
+
+  if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
+    DeclMap()->SetLookupsEnabled(true);
+  }
+
+  Process *process = exe_ctx.GetProcessPtr();
+  ExecutionContextScope *exe_scope = process;
+
+  if (!exe_scope)
+    exe_scope = exe_ctx.GetTargetPtr();
+
+  ClangExpressionParser parser(exe_scope, *this, false);
+
+  // We have to find the source code location where the user text is inside
+  // the transformed expression code. When creating the transformed text, we
+  // already stored the absolute position in the m_transformed_text string. The
+  // only thing left to do is to transform it into the line:column format that
+  // Clang expects.
+
+  // The line and column of the user expression inside the transformed source
+  // code.
+  unsigned user_expr_line, user_expr_column;
+  if (m_user_expression_start_pos.hasValue())
+    AbsPosToLineColumnPos(*m_user_expression_start_pos, m_transformed_text,
+                          user_expr_line, user_expr_column);
+  else
+    return false;
+
+  // The actual column where we have to complete is the start column of the
+  // user expression + the offset inside the user code that we were given.
+  const unsigned completion_column = user_expr_column + complete_pos;
+  parser.Complete(matches, user_expr_line, completion_column, complete_pos);
+
+  return true;
+}
+
 bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
                                        std::vector<lldb::addr_t> &args,
                                        lldb::addr_t struct_address,
                                        DiagnosticManager &diagnostic_manager) {
   lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
   lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
 
   if (m_needs_object_ptr) {