Add descriptions to completed expressions

[teemperor]

Summary

Completing inside the expression command now uses the new description API
to also provide additional information to the user. For now this information
are the types of variables/fields and the signatures of completed function calls.

[JDevlieghere]

LGTM!

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

def test_expr_completion(self):
         # 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()')
 
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
+    def test_expr_completion_with_descriptions(self):
+        self.build()
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                          '// Break here', self.main_source_spec)
+
+        self.check_completion_with_desc("expr ", [
+            # VarDecls have their type as description.
+            ["some_expr", "Expr &"],
+            # builtin types have no description.
+            ["int", ""],
+            ["float", ""]
+        ])
+        self.check_completion_with_desc("expr some_expr.", [
+            # Functions have their signature as description.
+            ["some_expr.Self()", "Expr &Self()"],
+            ["some_expr.operator=(", "inline Expr &operator=(const Expr &)"],
+            ["some_expr.FooNumbersBar1()", "int FooNumbersBar1()"],
+            ["some_expr.StaticMemberMethodBar()", "static int StaticMemberMethodBar()"],
+            ["some_expr.FooWithArgsBar(", "int FooWithArgsBar(int)"],
+            ["some_expr.FooNoArgsBar()", "int FooNoArgsBar()"],
+            ["some_expr.FooUnderscoreBar_()", "int FooUnderscoreBar_()"],
+            ["some_expr.FooWithMultipleArgsBar(", "int FooWithMultipleArgsBar(int, int)"],
+            ["some_expr.~Expr()", "inline ~Expr()"],
+            # FieldDecls have their type as description.
+            ["some_expr.MemberVariableBar", "int"],
+        ])
+
+
     def assume_no_completions(self, str_input, cursor_pos = None):
         interp = self.dbg.GetCommandInterpreter()
         match_strings = lldb.SBStringList()
         if cursor_pos is None:
           cursor_pos = len(str_input)
         num_matches = interp.HandleCompletion(str_input, cursor_pos, 0, -1, match_strings)
 
         available_completions = []

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 //===-- ClangExpressionParser.cpp -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 #include <cctype> // for alnum
 // Other libraries and framework includes
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ExternalASTSource.h"
+#include "clang/AST/PrettyPrinter.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/CodeGen/CodeGenAction.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Edit/Commit.h"

 /// of an incomplete `expr` invocation.
 //----------------------------------------------------------------------
 class CodeComplete : public CodeCompleteConsumer {
   CodeCompletionTUInfo m_info;
 
   std::string m_expr;
   unsigned m_position = 0;
   CompletionRequest &m_request;
+  /// The printing policy we use when printing declarations for our completion
+  /// descriptions.
+  clang::PrintingPolicy m_desc_policy;
 
   /// 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 == '$';
public:
   ///    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(CompletionRequest &request, std::string expr, unsigned position)
+  CodeComplete(CompletionRequest &request, clang::LangOptions ops,
+               std::string expr, unsigned position)
       : CodeCompleteConsumer(CodeCompleteOptions(), false),
         m_info(std::make_shared<GlobalCodeCompletionAllocator>()), m_expr(expr),
-        m_position(position), m_request(request) {}
+        m_position(position), m_request(request), m_desc_policy(ops) {
+
+    // Ensure that the printing policy is producing a description that is as
+    // short as possible.
+    m_desc_policy.SuppressScope = true;
+    m_desc_policy.SuppressTagKeyword = true;
+    m_desc_policy.FullyQualifiedName = false;
+    m_desc_policy.TerseOutput = true;
+    m_desc_policy.IncludeNewlines = false;
+    m_desc_policy.UseVoidForZeroParams = false;
+    m_desc_policy.Bool = true;
+  }
 
   /// 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 {
void ProcessCodeCompleteResults(Sema &SemaRef, CodeCompletionContext Context,
     // 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;
+      std::string Description;
       // 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 += "(";
-        }
+          raw_string_ostream OS(Description);
+          F->print(OS, m_desc_policy, false);
+          OS.flush();
+        } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
+          Description = V->getType().getAsString(m_desc_policy);
+        } else if (const FieldDecl *F = dyn_cast<FieldDecl>(D)) {
+          Description = F->getType().getAsString(m_desc_policy);
+        } else if (const NamespaceDecl *N = dyn_cast<NamespaceDecl>(D)) {
           // If we try to complete a namespace, then we can directly append
           // the '::'.
-        if (const NamespaceDecl *N = dyn_cast<NamespaceDecl>(D)) {
           if (!N->isAnonymousNamespace())
             ToInsert += "::";
         }
         break;
       }
       case CodeCompletionResult::RK_Keyword:
         ToInsert = R.Keyword;
         break;
for (unsigned I = 0; I != NumResults; ++I) {
       // 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(m_expr, m_position, ToInsert);
-        m_request.AddCompletion(CompletionSuggestion);
+        m_request.AddCompletion(CompletionSuggestion, Description);
       }
     }
   }
 
   /// \param S the semantic-analyzer object for which code-completion is being
   /// done.
   ///
   /// \param CurrentArg the index of the current argument.
bool ClangExpressionParser::Complete(CompletionRequest &request, unsigned line,
   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(request, llvm_expr.GetUserText(), typed_pos);
+  CodeComplete CC(request, m_compiler->getLangOpts(), 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) {