[clang][ASTContext] Try to avoid sorting comments for code completion

[jkorous]

Summary

For large number of deserialized comments (~100k) the way how we try to attach them to declaration in completion comments is too expensive.

Currently we're sorting all the comments by source location (expensive) and later bisecting them for every interesting declaration to find the closest comment before and after the declaration documentation comment.

This patch tries to just iterate over unsorted comments and see if there's any of the decls we're interested in nearby.

[gribozavr]

clang/include/clang/AST/ASTContext.h

800

Why not DenseMap?

808

Use ArrayRef.

clang/lib/AST/ASTContext.cpp

303

I'm really worried about all the logic duplication here vs. existing code.

clang/lib/AST/RawCommentList.cpp

366

Why is merging in RawCommentList::addComment not sufficient?

clang/lib/Sema/SemaCodeComplete.cpp

3180

There are only a couple of callers of this function, can we change them all to provide a comment if it exists?

3398

This method decl logic looks out of place here. It should be pushed down into the core logic for attaching comments.

[jkorous]

@gribozavr thanks for the feedback. I'm rewriting the patch now as I figured out my detection of comments preceding declarations is unsound.

[jkorous]

Abandoned in favor of
https://reviews.llvm.org/D65301

clang/include/clang/AST/ASTContext.h

   /// without looking into cache.
   RawComment *getRawCommentForDeclNoCache(const Decl *D) const;
 
+  /// Return the documentation comments attached to a given declarations,
+  /// without looking into cache.
+  /// The result doesn't contain decls that don't have any comment attached.
+  std::unordered_map<const Decl *, RawComment *> getRawCommentsForDeclsNoCache(
+      const std::unordered_map<const Decl *, std::vector<const Decl *>>
+          &ReDecls) const;
+
+  /// Return the documentation comment attached to any redeclaration of given
+  /// declarations. The result doesn't contain decls that don't have any comment
+  /// attached.
+  std::unordered_map<const Decl *, RawComment *>
+  getRawCommentsForAnyRedecls(const std::vector<const Decl *> &NDs) const;
+
 public:
   RawCommentList &getRawCommentList() {
     return Comments;

clang/include/clang/AST/RawCommentList.h

   }
 };
 
-/// This class represents all comments included in the translation unit,
-/// sorted in order of appearance in the translation unit.
+/// This class represents all comments included in the translation unit.
 class RawCommentList {
 public:
-  RawCommentList(SourceManager &SourceMgr) : SourceMgr(SourceMgr) {}
+  RawCommentList(SourceManager &SourceMgr)
+      : SourceMgr(SourceMgr), CommentsSorted(true) {}
 
   void addComment(const RawComment &RC, const CommentOptions &CommentOpts,
                   llvm::BumpPtrAllocator &Allocator);
 
-  ArrayRef<RawComment *> getComments() const {
+  ArrayRef<RawComment *> getComments(bool Sorted) const {
+    if (Sorted && !CommentsSorted)
+      sort();
     return Comments;
   }
 
+  /// Sorts comments using BeforeThanCompare<RawComment> ordering.
+  void sort() const;
+
+  /// Merge comments only if there is only whitespace between them.
+  /// Merge comments if they are on same or consecutive lines.
+  /// Sorts comments unless they are already sorted.
+  ///
+  /// Can't merge trailing and non-trailing comments unless the second is
+  /// non-trailing ordinary in the same column, as in the case:
+  ///   int x; // documents x
+  ///          // more text
+  /// versus:
+  ///   int x; // documents x
+  ///   int y; // documents y
+  /// or:
+  ///   int x; // documents x
+  ///   // documents y
+  ///   int y;
+  void merge(const CommentOptions& CommentOpts) const;
+
 private:
   SourceManager &SourceMgr;
-  std::vector<RawComment *> Comments;
+
+  mutable std::vector<RawComment *> Comments;
+  mutable bool CommentsSorted;
 
   void addDeserializedComments(ArrayRef<RawComment *> DeserializedComments);
 

clang/include/clang/Basic/SourceLocation.h

 
 } // namespace llvm
 
+namespace std {
+template <> struct hash<clang::SourceLocation> {
+  typedef clang::SourceLocation argument_type;
+  typedef unsigned result_type;
+  result_type operator()(argument_type const &SL) const noexcept {
+    return SL.getRawEncoding();
+  }
+};
+
+template <> struct hash<clang::FileID> {
+  typedef clang::FileID argument_type;
+  typedef int result_type;
+  result_type operator()(argument_type const &FID) const noexcept {
+    return FID.getHashValue();
+  }
+};
+} // namespace std
+
 #endif // LLVM_CLANG_BASIC_SOURCELOCATION_H

clang/include/clang/Sema/CodeCompleteConsumer.h

 #include <cassert>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <utility>
 
 namespace clang {

   ///
   /// \param Allocator The allocator that will be used to allocate the
   /// string itself.
-  CodeCompletionString *CreateCodeCompletionString(Sema &S,
-                                         const CodeCompletionContext &CCContext,
-                                           CodeCompletionAllocator &Allocator,
-                                           CodeCompletionTUInfo &CCTUInfo,
-                                           bool IncludeBriefComments);
-  CodeCompletionString *CreateCodeCompletionString(ASTContext &Ctx,
-                                                   Preprocessor &PP,
-                                         const CodeCompletionContext &CCContext,
-                                           CodeCompletionAllocator &Allocator,
-                                           CodeCompletionTUInfo &CCTUInfo,
-                                           bool IncludeBriefComments);
+  CodeCompletionString *CreateCodeCompletionString(
+      Sema &S, const CodeCompletionContext &CCContext,
+      CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
+      bool IncludeBriefComments, const RawComment *Comment = nullptr);
+  CodeCompletionString *CreateCodeCompletionString(
+      ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext,
+      CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
+      bool IncludeBriefComments, const RawComment *Comment = nullptr);
   /// Creates a new code-completion string for the macro result. Similar to the
   /// above overloads, except this only requires preprocessor information.
   /// The result kind must be `RK_Macro`.

   CodeCompletionString *createCodeCompletionStringForDecl(
       Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
       bool IncludeBriefComments, const CodeCompletionContext &CCContext,
-      PrintingPolicy &Policy);
+      PrintingPolicy &Policy, const RawComment *Comment = nullptr);
 
   CodeCompletionString *createCodeCompletionStringForOverride(
       Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,

 const RawComment *getCompletionComment(const ASTContext &Ctx,
                                        const NamedDecl *Decl);
 
+/// Return comments attributed to \param NDs in \param Ctx
+std::unordered_map<const Decl *, RawComment *>
+getCompletionComments(const ASTContext &Ctx,
+                      const std::vector<const Decl *> &Ds);
+
 /// Get the documentation comment used to produce
 /// CodeCompletionString::BriefComment for RK_Pattern.
 const RawComment *getPatternCompletionComment(const ASTContext &Ctx,

clang/lib/AST/ASTContext.cpp

   return DeclLoc;
 };
 
+static void getDeclLocationsForCommentSearch(
+    SourceManager &SrcMgr,
+    const std::unordered_map<const Decl *, std::vector<const Decl *>>
+        &DeclToRedecls,
+    std::unordered_map<FileID,
+                       std::unordered_map<unsigned, std::vector<const Decl *>>>
+        &FileToLineToDecls,
+    std::unordered_map<FileID,
+                       std::unordered_map<unsigned, std::vector<const Decl *>>>
+        &FileToOffsetToDecls) {
+  for (auto It : DeclToRedecls) {
+    if (llvm::Optional<SourceLocation> OptLoc =
+            getCandidateCommentLocation(SrcMgr, It.first)) {
+      auto Loc = OptLoc.getValue();
+      const std::pair<FileID, unsigned> DecompLoc =
+          SrcMgr.getDecomposedLoc(Loc);
+      FileToOffsetToDecls[DecompLoc.first][DecompLoc.second].push_back(
+          It.first);
+      const unsigned Line =
+          SrcMgr.getLineNumber(DecompLoc.first, DecompLoc.second);
+      FileToLineToDecls[DecompLoc.first][Line].push_back(It.first);
+    }
+  }
+
+  for (auto It : DeclToRedecls) {
+    for (auto *D : It.second) {
+      if (llvm::Optional<SourceLocation> OptLoc =
+              getCandidateCommentLocation(SrcMgr, D)) {
+        auto Loc = OptLoc.getValue();
+        const std::pair<FileID, unsigned> DecompLoc =
+            SrcMgr.getDecomposedLoc(Loc);
+        FileToOffsetToDecls[DecompLoc.first][DecompLoc.second].push_back(D);
+        const unsigned Line =
+            SrcMgr.getLineNumber(DecompLoc.first, DecompLoc.second);
+        FileToLineToDecls[DecompLoc.first][Line].push_back(D);
+      }
+    }
+  }
+}
+
 // Assumes the comment is the closest comment before the decl - i. e. there's no
 // other comment between them.
 static bool IsCommentBeforeDecl(SourceManager &SrcMgr,

   return true;
 };
 
+std::unordered_map<const Decl *, RawComment *>
+ASTContext::getRawCommentsForDeclsNoCache(
+    const std::unordered_map<const Decl *, std::vector<const Decl *>> &ReDecls)
+    const {
+  if (!CommentsLoaded && ExternalSource) {
+    ExternalSource->ReadComments();
+    CommentsLoaded = true;
+  }
+
+  std::unordered_map<const Decl *, RawComment *> Result;
+
+  ArrayRef<RawComment *> RawComments = Comments.getComments(/*Sorted=*/false);
+  // If there are no comments anywhere, we won't find anything.
+  if (RawComments.empty())
+    return Result;
+
+  std::unordered_map<FileID,
+                     std::unordered_map<unsigned, std::vector<const Decl *>>>
+      FileToLineToDecls;
+  std::unordered_map<FileID,
+                     std::unordered_map<unsigned, std::vector<const Decl *>>>
+      FileToOffsetToDecls;
+
+  getDeclLocationsForCommentSearch(SourceMgr, ReDecls, FileToLineToDecls,
+                                   FileToOffsetToDecls);
+
+  auto CheckDeclsOnTheSameLine = [&, this](RawComment *Comment) {
+    const std::pair<FileID, unsigned> CommentBegin =
+        SourceMgr.getDecomposedLoc(Comment->getSourceRange().getBegin());
+
+    const auto DeclsInTheFileIt = FileToLineToDecls.find(CommentBegin.first);
+    if (DeclsInTheFileIt == FileToLineToDecls.end()) {
+      return;
+    }
+
+    const unsigned CommentBeginLine =
+        SourceMgr.getLineNumber(CommentBegin.first, CommentBegin.second);
+    const auto DeclsOnTheLineIt =
+        DeclsInTheFileIt->second.find(CommentBeginLine);
+    if (DeclsOnTheLineIt == DeclsInTheFileIt->second.end()) {
+      return;
+    }
+
+    for (auto *D : DeclsOnTheLineIt->second) {
+      if ((isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
+           isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {
+        Result[D] = Comment;
+      }
+    }
+  };
+
+  auto CheckDeclsRightBehind = [&, this](RawComment *Comment) {
+    const std::pair<FileID, unsigned> CommentEnd =
+        SourceMgr.getDecomposedLoc(Comment->getSourceRange().getEnd());
+
+    // If the comment and the declaration aren't in the same file, then they
+    // aren't related.
+    const auto DeclsInTheFileIt = FileToOffsetToDecls.find(CommentEnd.first);
+    if (DeclsInTheFileIt == FileToOffsetToDecls.end()) {
+      return;
+    }
+
+    std::pair<FileID, unsigned> TmpDeclLoc(DeclsInTheFileIt->first,
+                                           /* bogus */ 0);
+    for (const auto &OffsetToDeclsIt : DeclsInTheFileIt->second) {
+      TmpDeclLoc.second = OffsetToDeclsIt.first;
+      if (!IsCommentBeforeDecl(SourceMgr, CommentEnd, TmpDeclLoc))
+        continue;
+
+      // There can be multiple declaration at the same offset.
+      for (const auto &D : OffsetToDeclsIt.second) {
+        Result[D] = Comment;
+      }
+    }
+  };
+
+  for (auto RC : RawComments) {
+    if (LangOpts.CommentOpts.ParseAllComments || RC->isDocumentation()) {
+      if (RC->isTrailingComment()) {
+        CheckDeclsOnTheSameLine(RC);
+      } else {
+        CheckDeclsRightBehind(RC);
+      }
+    }
+  }
+
+  return Result;
+}
+
 /// Returns true iff \param D can have a documentation comment attached.
 static bool CanDeclHaveDocComment(const Decl *D) {
   if (!D)

 
   // If we already tried to load comments but there are none,
   // we won't find anything.
-  if (CommentsLoaded && Comments.getComments().empty())
+  if (CommentsLoaded && Comments.getComments(/*Sorted=*/false).empty())
     return nullptr;
 
   if (!CanDeclHaveDocComment(D))

 
   if (!CommentsLoaded && ExternalSource) {
     ExternalSource->ReadComments();
-
-#ifndef NDEBUG
-    ArrayRef<RawComment *> RawComments = Comments.getComments();
-    assert(std::is_sorted(RawComments.begin(), RawComments.end(),
-                          BeforeThanCompare<RawComment>(SourceMgr)));
-#endif
-
     CommentsLoaded = true;
   }
 
-  ArrayRef<RawComment *> RawComments = Comments.getComments();
+  ArrayRef<RawComment *> RawComments = Comments.getComments(/*Sorted=*/true);
+
+#ifndef NDEBUG
+  assert(std::is_sorted(RawComments.begin(), RawComments.end(),
+                        BeforeThanCompare<RawComment>(SourceMgr)));
+#endif
 
   // If there are no comments anywhere, we won't find anything.
   if (RawComments.empty())

   return D;
 }
 
+std::unordered_map<const Decl *, RawComment *>
+ASTContext::getRawCommentsForAnyRedecls(
+    const std::vector<const Decl *> &Ds) const {
+
+  // mapping from decl to it's re-decls
+  std::unordered_map<const Decl *, std::vector<const Decl *>> ReDecls;
+  ReDecls.reserve(Ds.size());
+
+  for (const auto *D : Ds) {
+    if (!CanDeclHaveDocComment(D))
+      continue;
+
+    D = adjustDeclToTemplate(D);
+    std::vector<const Decl *> RedeclsForDecl;
+    for (auto I : D->redecls()) {
+      if (I == D)
+        continue;
+      if (const auto RD = dyn_cast<NamedDecl>(I))
+        RedeclsForDecl.push_back(RD);
+    }
+    ReDecls[D] = RedeclsForDecl;
+  }
+  return getRawCommentsForDeclsNoCache(ReDecls);
+}
+
 const RawComment *ASTContext::getRawCommentForAnyRedecl(
                                                 const Decl *D,
                                                 const Decl **OriginalDecl) const {

 void ASTContext::tryToAttachCommentsToDecls(ArrayRef<Decl *> Decls, const Preprocessor *PP) {
   // Explicitly not calling ExternalSource->ReadComments() as we're not
   // interested in those.
-  ArrayRef<RawComment *> RawComments = Comments.getComments();
+  ArrayRef<RawComment *> RawComments = Comments.getComments(/*Sorted=*/false);
   if (RawComments.empty())
     return;
 

clang/lib/AST/RawCommentList.cpp

   if (RC.isInvalid())
     return;
 
-  // Check if the comments are not in source order.
-  while (!Comments.empty() &&
-         !SourceMgr.isBeforeInTranslationUnit(Comments.back()->getBeginLoc(),
-                                              RC.getBeginLoc())) {
-    // If they are, just pop a few last comments that don't fit.
-    // This happens if an \#include directive contains comments.
-    Comments.pop_back();
-  }
-
   // Ordinary comments are not interesting for us.
   if (RC.isOrdinary() && !CommentOpts.ParseAllComments)
     return;

   } else {
     Comments.push_back(new (Allocator) RawComment(RC));
   }
+
+  CommentsSorted = false;
+}
+
+void RawCommentList::sort() const {
+  if (CommentsSorted)
+    return;
+
+  llvm::sort(Comments.begin(), Comments.end(),
+             BeforeThanCompare<RawComment>(SourceMgr));
+}
+
+void RawCommentList::merge(const CommentOptions& CommentOpts) const {
+  if (Comments.size() < 2)
+    return;
+
+  if (!CommentsSorted)
+    sort();
+
+  auto C1 = Comments.begin();
+  auto C2 = C1;
+  ++C2;
+
+  while (C2 != Comments.end()) {
+    std::pair<FileID, unsigned> Loc1Info =
+        SourceMgr.getDecomposedLoc((*C1)->getEndLoc());
+    std::pair<FileID, unsigned> Loc2Info =
+        SourceMgr.getDecomposedLoc((*C2)->getBeginLoc());
+    // FIXME: Ignoring overlapping comments.
+    if (Loc1Info.second > Loc2Info.second) {
+      ++C1;
+      ++C2;
+      continue;
+    }
+
+    if (((*C1)->isTrailingComment() == (*C2)->isTrailingComment() ||
+         ((*C1)->isTrailingComment() && !(*C2)->isTrailingComment() &&
+          isOrdinaryKind((*C2)->getKind()) &&
+          commentsStartOnSameColumn(SourceMgr, **C1, **C2))) &&
+        onlyWhitespaceBetween(SourceMgr, Loc1Info, Loc2Info,
+                              /*MaxNewlinesAllowed=*/1)) {
+      SourceRange MergedRange((*C1)->getBeginLoc(), (*C2)->getEndLoc());
+      **C1 = RawComment(SourceMgr, MergedRange, CommentOpts, true);
+      Comments.erase(C2);
+      C2 = C1;
+      ++C2;
+    } else {
+      ++C1;
+      ++C2;
+    }
+  }
 }
 
 void RawCommentList::addDeserializedComments(ArrayRef<RawComment *> DeserializedComments) {

              std::back_inserter(MergedComments),
              BeforeThanCompare<RawComment>(SourceMgr));
   std::swap(Comments, MergedComments);
+  // FIXME: This could be relaxed in some cases.
+  CommentsSorted = false;
 }
 
 std::string RawComment::getFormattedText(const SourceManager &SourceMgr,

clang/lib/Sema/SemaCodeComplete.cpp

 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
     Sema &S, const CodeCompletionContext &CCContext,
     CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
-    bool IncludeBriefComments) {
+    bool IncludeBriefComments, const RawComment *Comment) {
   return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
-                                    CCTUInfo, IncludeBriefComments);
+                                    CCTUInfo, IncludeBriefComments, Comment);
 }
 
 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro(

 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
     ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext,
     CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
-    bool IncludeBriefComments) {
+    bool IncludeBriefComments, const RawComment *Comment) {
   if (Kind == RK_Macro)
     return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
 

   }
   assert(Kind == RK_Declaration && "Missed a result kind?");
   return createCodeCompletionStringForDecl(
-      PP, Ctx, Result, IncludeBriefComments, CCContext, Policy);
+      PP, Ctx, Result, IncludeBriefComments, CCContext, Policy, Comment);
 }
 
 CodeCompletionString *

 CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl(
     Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
     bool IncludeBriefComments, const CodeCompletionContext &CCContext,
-    PrintingPolicy &Policy) {
+    PrintingPolicy &Policy, const RawComment *Comment) {
   const NamedDecl *ND = Declaration;
   Result.addParentContext(ND->getDeclContext());
 
   if (IncludeBriefComments) {
+    // Try to get the comment if it wasn't provided
+    if (!Comment)
+      Comment = getCompletionComment(Ctx, Declaration);
+
     // Add documentation comment, if it exists.
-    if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
-      Result.addBriefComment(RC->getBriefText(Ctx));
-    }
+    if (Comment)
+      Result.addBriefComment(Comment->getBriefText(Ctx));
   }
 
   if (StartsNestedNameSpecifier) {

   return Ctx.getRawCommentForAnyRedecl(PDecl);
 }
 
+std::unordered_map<const Decl *, RawComment *>
+clang::getCompletionComments(const ASTContext &Ctx,
+                             const std::vector<const Decl *> &NDs) {
+  std::vector<const Decl *> Decls = NDs;
+  for (const auto *const ND : NDs) {
+    if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND)) {
+      if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl()) {
+        Decls.push_back(dyn_cast<NamedDecl>(PDecl));
+      }
+    }
+  }
+
+  return Ctx.getRawCommentsForAnyRedecls(Decls);
+}
+
 const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx,
                                                      const NamedDecl *ND) {
   const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND);

clang/lib/Serialization/ASTReader.cpp

   NextCursor:
     // De-serialized SourceLocations get negative FileIDs for other modules,
     // potentially invalidating the original order. Sort it again.
-    llvm::sort(Comments, BeforeThanCompare<RawComment>(SourceMgr));
     Context.Comments.addDeserializedComments(Comments);
   }
 }

clang/lib/Serialization/ASTWriter.cpp

   auto _ = llvm::make_scope_exit([this] { Stream.ExitBlock(); });
   if (!PP->getPreprocessorOpts().WriteCommentListToPCH)
     return;
-  ArrayRef<RawComment *> RawComments = Context->Comments.getComments();
+  ArrayRef<RawComment *> RawComments =
+      Context->Comments.getComments(/*Sorted=*/false);
+  Context->Comments.sort();
+  Context->Comments.merge(Context->getLangOpts().CommentOpts);
+
   RecordData Record;
   for (const auto *I : RawComments) {
     Record.clear();

clang/tools/libclang/CIndexCodeCompletion.cpp

       StoredResults.reserve(StoredResults.size() + NumResults);
       if (includeFixIts())
         AllocatedResults.FixItsVector.reserve(NumResults);
+
+      auto CanResultHaveComment =
+          [](const CodeCompletionResult &Result) -> bool {
+        const auto &Kind = Result.Kind;
+
+        if (Kind == CodeCompletionResult::RK_Declaration ||
+            Kind == CodeCompletionResult::RK_Pattern) {
+          if (auto D = Result.getDeclaration()) {
+            return true;
+          }
+        }
+
+        return false;
+      };
+
+      std::vector<const Decl *> DeclsThatCanHaveCommentAttached;
       for (unsigned I = 0; I != NumResults; ++I) {
-        CodeCompletionString *StoredCompletion
-          = Results[I].CreateCodeCompletionString(S, Context, getAllocator(),
-                                                  getCodeCompletionTUInfo(),
-                                                  includeBriefComments());
-        
+        if (CanResultHaveComment(Results[I])) {
+          if (auto D = Results[I].getDeclaration()) {
+            DeclsThatCanHaveCommentAttached.push_back(D);
+          }
+        }
+      }
+
+      auto Cache = getCompletionComments(S.getASTContext(),
+                                         DeclsThatCanHaveCommentAttached);
+
+      for (unsigned I = 0; I != NumResults; ++I) {
+        const RawComment *Comment = nullptr;
+        if (CanResultHaveComment(Results[I])) {
+          const auto CachedValueIt = Cache.find(Results[I].getDeclaration());
+          if (CachedValueIt != Cache.end()) {
+            Comment = CachedValueIt->second;
+          }
+        }
+        CodeCompletionString *StoredCompletion =
+            Results[I].CreateCodeCompletionString(
+                S, Context, getAllocator(), getCodeCompletionTUInfo(),
+                includeBriefComments(), Comment);
+
         CXCompletionResult R;
         R.CursorKind = Results[I].CursorKind;
         R.CompletionString = StoredCompletion;