[lldb] returning command completions up to a maximum

- Adding `max_return_elements` field to `CompletionRequest`.
- adding maximum checks to `SymbolCompleter` and `SourceFileCompleter`.

Author: eronnen

lldb/include/lldb/Utility/CompletionRequest.h

@@ -115,6 +115,25 @@ class CompletionRequest {
   CompletionRequest(llvm::StringRef command_line, unsigned raw_cursor_pos,
                     CompletionResult &result);
 
+  /// Constructs a completion request.
+  ///
+  /// \param [in] command_line
+  ///     The command line the user has typed at this point.
+  ///
+  /// \param [in] raw_cursor_pos
+  ///     The position of the cursor in the command line string. Index 0 means
+  ///     the cursor is at the start of the line. The completion starts from
+  ///     this cursor position.
+  ///
+  /// \param [in] max_return_elements
+  ///     The maximum number of completions that should be returned.
+  ///
+  /// \param [out] result
+  ///     The CompletionResult that will be filled with the results after this
+  ///     request has been handled.
+  CompletionRequest(llvm::StringRef command_line, unsigned raw_cursor_pos,
+                    size_t max_return_elements, CompletionResult &result);
+
   /// Returns the raw user input used to create this CompletionRequest cut off
   /// at the cursor position. The cursor will be at the end of the raw line.
   llvm::StringRef GetRawLine() const {
@@ -157,6 +176,23 @@ class CompletionRequest {
 
   size_t GetCursorIndex() const { return m_cursor_index; }
 
+  size_t GetMaxReturnElements() const { return m_max_return_elements; }
+
+  /// Returns true if the maximum number of completions has been reached
+  /// already.
+  bool ShouldStopAddingResults() const {
+    return m_result.GetNumberOfResults() >= m_max_return_elements;
+  }
+
+  /// Returns the maximum number of completions that need to be added
+  /// until reaching the maximum
+  size_t GetMaxNumberOfResultsToAdd() const {
+    const size_t number_of_results = m_result.GetNumberOfResults();
+    if (number_of_results >= m_max_return_elements)
+      return 0;
+    return m_max_return_elements - number_of_results;
+  }
+
   /// Adds a possible completion string. If the completion was already
   /// suggested before, it will not be added to the list of results. A copy of
   /// the suggested completion is stored, so the given string can be free'd
@@ -231,6 +267,8 @@ class CompletionRequest {
   size_t m_cursor_index;
   /// The cursor position in the argument indexed by m_cursor_index.
   size_t m_cursor_char_position;
+  /// The maximum number of completions that should be returned.
+  size_t m_max_return_elements;
 
   /// The result this request is supposed to fill out.
   /// We keep this object private to ensure that no backend can in any way

lldb/source/API/SBCommandInterpreter.cpp

@@ -263,9 +263,13 @@ int SBCommandInterpreter::HandleCompletionWithDescriptions(
   if (!IsValid())
     return 0;
 
+  if (0 >= max_return_elements)
+    return 0;
+
   lldb_private::StringList lldb_matches, lldb_descriptions;
   CompletionResult result;
-  CompletionRequest request(current_line, cursor - current_line, result);
+  CompletionRequest request(current_line, cursor - current_line,
+                            static_cast<size_t>(max_return_elements), result);
   m_opaque_ptr->HandleCompletion(request);
   result.GetMatches(lldb_matches);
   result.GetDescriptions(lldb_descriptions);

lldb/source/Commands/CommandCompletions.cpp

@@ -91,7 +91,7 @@ bool CommandCompletions::InvokeCommonCompletionCallbacks(
        nullptr} // This one has to be last in the list.
   };
 
-  for (int i = 0;; i++) {
+  for (int i = 0; !request.ShouldStopAddingResults(); i++) {
     if (common_completions[i].type == lldb::eTerminatorCompletion)
       break;
     else if ((common_completions[i].type & completion_mask) ==
@@ -167,7 +167,9 @@ class SourceFileCompleter : public Completer {
         m_matching_files.AppendIfUnique(context.comp_unit->GetPrimaryFile());
       }
     }
-    return Searcher::eCallbackReturnContinue;
+    return m_matching_files.GetSize() >= m_request.GetMaxNumberOfResultsToAdd()
+               ? Searcher::eCallbackReturnStop
+               : Searcher::eCallbackReturnContinue;
   }
 
   void DoCompletion(SearchFilter *filter) override {
@@ -230,6 +232,10 @@ class SymbolCompleter : public Completer {
 
       // Now add the functions & symbols to the list - only add if unique:
       for (const SymbolContext &sc : sc_list) {
+        if (m_match_set.size() >= m_request.GetMaxNumberOfResultsToAdd()) {
+          break;
+        }
+
         ConstString func_name = sc.GetFunctionName(Mangled::ePreferDemangled);
         // Ensure that the function name matches the regex. This is more than
         // a sanity check. It is possible that the demangled function name
@@ -239,7 +245,9 @@ class SymbolCompleter : public Completer {
           m_match_set.insert(func_name);
       }
     }
-    return Searcher::eCallbackReturnContinue;
+    return m_match_set.size() >= m_request.GetMaxNumberOfResultsToAdd()
+               ? Searcher::eCallbackReturnStop
+               : Searcher::eCallbackReturnContinue;
   }
 
   void DoCompletion(SearchFilter *filter) override {

lldb/source/Utility/CompletionRequest.cpp

@@ -14,8 +14,15 @@ using namespace lldb_private;
 CompletionRequest::CompletionRequest(llvm::StringRef command_line,
                                      unsigned raw_cursor_pos,
                                      CompletionResult &result)
+    : CompletionRequest(std::move(command_line), raw_cursor_pos, SIZE_MAX,
+                        result) {}
+
+CompletionRequest::CompletionRequest(llvm::StringRef command_line,
+                                     unsigned raw_cursor_pos,
+                                     size_t max_return_elements,
+                                     CompletionResult &result)
     : m_command(command_line), m_raw_cursor_pos(raw_cursor_pos),
-      m_result(result) {
+      m_max_return_elements(max_return_elements), m_result(result) {
   assert(raw_cursor_pos <= command_line.size() && "Out of bounds cursor?");
 
   // We parse the argument up to the cursor, so the last argument in