Merge pull request swiftlang#41400 from rintaro/completion-fitername-precompute

[CodeCompletion] Precompute "filter name"

Author: rintaro

include/swift/Basic/StringExtras.h

@@ -52,12 +52,16 @@ namespace swift {
   /// Determine the part of speech for the given word.
   PartOfSpeech getPartOfSpeech(StringRef word);
 
+  /// Copy \p string to \p Allocator and return it as a null terminated C
+  /// string.
+  const char *copyCString(StringRef string, llvm::BumpPtrAllocator &Allocator);
+
   /// Scratch space used for returning a set of StringRefs.
   class StringScratchSpace {
     llvm::BumpPtrAllocator Allocator;
 
   public:
-    StringRef copyString(StringRef string);
+    StringRef copyString(StringRef string) { return string.copy(Allocator); }
 
     llvm::BumpPtrAllocator &getAllocator() { return Allocator; }
   };
@@ -465,6 +469,52 @@ bool omitNeedlessWords(StringRef &baseName,
 /// If the name has a completion-handler suffix, strip off that suffix.
 Optional<StringRef> stripWithCompletionHandlerSuffix(StringRef name);
 
+/// Represents a string that can be efficiently retrieved either as a StringRef
+/// or as a null-terminated C string.
+class NullTerminatedStringRef {
+  StringRef Ref;
+
+public:
+  /// Create a \c NullTerminatedStringRef from a null-terminated C string with
+  /// size \p Size (excluding the null character).
+  NullTerminatedStringRef(const char *Data, size_t Size) : Ref(Data, Size) {
+    assert(Data != nullptr && Data[Size] == '\0' &&
+           "Data should be null-terminated");
+  }
+
+  /// Create an empty null-terminated string. \c data() is not a \c nullptr.
+  constexpr NullTerminatedStringRef() : Ref("") {}
+
+  /// Create an null terminated string with a C string.
+  constexpr NullTerminatedStringRef(const char *Data) : Ref(Data) {}
+
+  /// Create a null-terminated string, copying \p Str into \p A .
+  template <typename Allocator>
+  NullTerminatedStringRef(StringRef Str, Allocator &A) : Ref("") {
+    if (Str.empty())
+      return;
+
+    size_t size = Str.size();
+    char *memory = A.template Allocate<char>(size + 1);
+    memcpy(memory, Str.data(), size);
+    memory[size] = '\0';
+    Ref = {memory, size};
+  }
+
+  /// Returns the string as a `StringRef`. The `StringRef` does not include the
+  /// null character.
+  operator StringRef() const { return Ref; }
+
+  /// Returns the string as a null-terminated C string.
+  const char *data() const { return Ref.data(); }
+
+  /// The size of the string, excluding the null character.
+  size_t size() const { return Ref.size(); }
+
+  bool empty() const { return Ref.empty(); }
+  int compare(NullTerminatedStringRef RHS) const { return Ref.compare(RHS); }
+};
+
 } // end namespace swift
 
 #endif // SWIFT_BASIC_STRINGEXTRAS_H

include/swift/IDE/CodeCompletion.h

@@ -18,6 +18,7 @@
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptionSet.h"
+#include "swift/Basic/StringExtras.h"
 #include "swift/Frontend/Frontend.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringMap.h"
@@ -64,12 +65,6 @@ std::string removeCodeCompletionTokens(StringRef Input,
                                        StringRef TokenName,
                                        unsigned *CompletionOffset);
 
-StringRef copyString(llvm::BumpPtrAllocator &Allocator,
-                     StringRef Str);
-
-const char *copyCString(llvm::BumpPtrAllocator &Allocator,
-                        StringRef Str);
-
 template <typename T>
 ArrayRef<T> copyArray(llvm::BumpPtrAllocator &Allocator,
                             ArrayRef<T> Arr) {
@@ -723,9 +718,9 @@ class ContextFreeCodeCompletionResult {
 
   bool IsSystem : 1;
   CodeCompletionString *CompletionString;
-  StringRef ModuleName;
-  StringRef BriefDocComment;
-  ArrayRef<StringRef> AssociatedUSRs;
+  NullTerminatedStringRef ModuleName;
+  NullTerminatedStringRef BriefDocComment;
+  ArrayRef<NullTerminatedStringRef> AssociatedUSRs;
   CodeCompletionResultType ResultType;
 
   ContextFreeNotRecommendedReason NotRecommended : 3;
@@ -734,7 +729,8 @@ class ContextFreeCodeCompletionResult {
   CodeCompletionDiagnosticSeverity DiagnosticSeverity : 3;
   static_assert(int(CodeCompletionDiagnosticSeverity::MAX_VALUE) < 1 << 3, "");
 
-  StringRef DiagnosticMessage;
+  NullTerminatedStringRef DiagnosticMessage;
+  NullTerminatedStringRef FilterName;
 
 public:
   /// Memberwise initializer. \p AssociatedKInd is opaque and will be
@@ -748,18 +744,21 @@ class ContextFreeCodeCompletionResult {
   ContextFreeCodeCompletionResult(
       CodeCompletionResultKind Kind, uint8_t AssociatedKind,
       CodeCompletionOperatorKind KnownOperatorKind, bool IsSystem,
-      CodeCompletionString *CompletionString, StringRef ModuleName,
-      StringRef BriefDocComment, ArrayRef<StringRef> AssociatedUSRs,
+      CodeCompletionString *CompletionString,
+      NullTerminatedStringRef ModuleName,
+      NullTerminatedStringRef BriefDocComment,
+      ArrayRef<NullTerminatedStringRef> AssociatedUSRs,
       CodeCompletionResultType ResultType,
       ContextFreeNotRecommendedReason NotRecommended,
       CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-      StringRef DiagnosticMessage)
+      NullTerminatedStringRef DiagnosticMessage,
+      NullTerminatedStringRef FilterName)
       : Kind(Kind), KnownOperatorKind(KnownOperatorKind), IsSystem(IsSystem),
         CompletionString(CompletionString), ModuleName(ModuleName),
         BriefDocComment(BriefDocComment), AssociatedUSRs(AssociatedUSRs),
         ResultType(ResultType), NotRecommended(NotRecommended),
         DiagnosticSeverity(DiagnosticSeverity),
-        DiagnosticMessage(DiagnosticMessage) {
+        DiagnosticMessage(DiagnosticMessage), FilterName(FilterName) {
     this->AssociatedKind.Opaque = AssociatedKind;
     assert((NotRecommended == ContextFreeNotRecommendedReason::None) ==
                (DiagnosticSeverity == CodeCompletionDiagnosticSeverity::None) &&
@@ -777,78 +776,58 @@ class ContextFreeCodeCompletionResult {
                "isOperator implies operator kind != None");
   }
 
-  /// Constructs a \c Pattern, \c Keyword or \c BuiltinOperator result.
+  /// Constructs a \c Pattern or \c BuiltinOperator result.
   ///
   /// \note The caller must ensure that the \p CompletionString and \c
   /// StringRefs outlive this result, typically by storing them in the same
   /// \c CodeCompletionResultSink as the result itself.
-  ContextFreeCodeCompletionResult(
-      CodeCompletionResultKind Kind, CodeCompletionString *CompletionString,
-      CodeCompletionOperatorKind KnownOperatorKind, StringRef BriefDocComment,
+  static ContextFreeCodeCompletionResult *createPatternOrBuiltInOperatorResult(
+      llvm::BumpPtrAllocator &Allocator, CodeCompletionResultKind Kind,
+      CodeCompletionString *CompletionString,
+      CodeCompletionOperatorKind KnownOperatorKind,
+      NullTerminatedStringRef BriefDocComment,
       CodeCompletionResultType ResultType,
       ContextFreeNotRecommendedReason NotRecommended,
       CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-      StringRef DiagnosticMessage)
-      : ContextFreeCodeCompletionResult(
-            Kind, /*AssociatedKind=*/0, KnownOperatorKind,
-            /*IsSystem=*/false, CompletionString, /*ModuleName=*/"",
-            BriefDocComment, /*AssociatedUSRs=*/{}, ResultType, NotRecommended,
-            DiagnosticSeverity, DiagnosticMessage) {}
+      NullTerminatedStringRef DiagnosticMessage);
 
   /// Constructs a \c Keyword result.
   ///
   /// \note The caller must ensure that the \p CompletionString and
-  /// \p BriefDocComment outlive this result, typically by storing them in the
-  /// same \c CodeCompletionResultSink as the result itself.
-  ContextFreeCodeCompletionResult(CodeCompletionKeywordKind Kind,
-                                  CodeCompletionString *CompletionString,
-                                  StringRef BriefDocComment,
-                                  CodeCompletionResultType ResultType)
-      : ContextFreeCodeCompletionResult(
-            CodeCompletionResultKind::Keyword, static_cast<uint8_t>(Kind),
-            CodeCompletionOperatorKind::None, /*IsSystem=*/false,
-            CompletionString, /*ModuleName=*/"", BriefDocComment,
-            /*AssociatedUSRs=*/{}, ResultType,
-            ContextFreeNotRecommendedReason::None,
-            CodeCompletionDiagnosticSeverity::None, /*DiagnosticMessage=*/"") {}
+  /// \p BriefDocComment outlive this result, typically by storing them in
+  /// the same \c CodeCompletionResultSink as the result itself.
+  static ContextFreeCodeCompletionResult *
+  createKeywordResult(llvm::BumpPtrAllocator &Allocator,
+                      CodeCompletionKeywordKind Kind,
+                      CodeCompletionString *CompletionString,
+                      NullTerminatedStringRef BriefDocComment,
+                      CodeCompletionResultType ResultType);
 
   /// Constructs a \c Literal result.
   ///
   /// \note The caller must ensure that the \p CompletionString outlives this
   /// result, typically by storing them in the same \c CodeCompletionResultSink
   /// as the result itself.
-  ContextFreeCodeCompletionResult(CodeCompletionLiteralKind LiteralKind,
-                                  CodeCompletionString *CompletionString,
-                                  CodeCompletionResultType ResultType)
-      : ContextFreeCodeCompletionResult(
-            CodeCompletionResultKind::Literal,
-            static_cast<uint8_t>(LiteralKind), CodeCompletionOperatorKind::None,
-            /*IsSystem=*/false, CompletionString, /*ModuleName=*/"",
-            /*BriefDocComment=*/"",
-            /*AssociatedUSRs=*/{}, ResultType,
-            ContextFreeNotRecommendedReason::None,
-            CodeCompletionDiagnosticSeverity::None, /*DiagnosticMessage=*/"") {}
+  static ContextFreeCodeCompletionResult *
+  createLiteralResult(llvm::BumpPtrAllocator &Allocator,
+                      CodeCompletionLiteralKind LiteralKind,
+                      CodeCompletionString *CompletionString,
+                      CodeCompletionResultType ResultType);
 
   /// Constructs a \c Declaration result.
   ///
   /// \note The caller must ensure that the \p CompletionString and all
   /// \c StringRefs outlive this result, typically by storing them in the same
   /// \c CodeCompletionResultSink as the result itself.
-  ContextFreeCodeCompletionResult(
-      CodeCompletionString *CompletionString, const Decl *AssociatedDecl,
-      StringRef ModuleName, StringRef BriefDocComment,
-      ArrayRef<StringRef> AssociatedUSRs, CodeCompletionResultType ResultType,
+  static ContextFreeCodeCompletionResult *createDeclResult(
+      llvm::BumpPtrAllocator &Allocator, CodeCompletionString *CompletionString,
+      const Decl *AssociatedDecl, NullTerminatedStringRef ModuleName,
+      NullTerminatedStringRef BriefDocComment,
+      ArrayRef<NullTerminatedStringRef> AssociatedUSRs,
+      CodeCompletionResultType ResultType,
       ContextFreeNotRecommendedReason NotRecommended,
       CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-      StringRef DiagnosticMessage)
-      : ContextFreeCodeCompletionResult(
-            CodeCompletionResultKind::Declaration,
-            static_cast<uint8_t>(getCodeCompletionDeclKind(AssociatedDecl)),
-            CodeCompletionOperatorKind::None, getDeclIsSystem(AssociatedDecl),
-            CompletionString, ModuleName, BriefDocComment, AssociatedUSRs,
-            ResultType, NotRecommended, DiagnosticSeverity, DiagnosticMessage) {
-    assert(AssociatedDecl && "should have a decl");
-  }
+      NullTerminatedStringRef DiagnosticMessage);
 
   CodeCompletionResultKind getKind() const { return Kind; }
 
@@ -878,11 +857,13 @@ class ContextFreeCodeCompletionResult {
 
   CodeCompletionString *getCompletionString() const { return CompletionString; }
 
-  StringRef getModuleName() const { return ModuleName; }
+  NullTerminatedStringRef getModuleName() const { return ModuleName; }
 
-  StringRef getBriefDocComment() const { return BriefDocComment; }
+  NullTerminatedStringRef getBriefDocComment() const { return BriefDocComment; }
 
-  ArrayRef<StringRef> getAssociatedUSRs() const { return AssociatedUSRs; }
+  ArrayRef<NullTerminatedStringRef> getAssociatedUSRs() const {
+    return AssociatedUSRs;
+  }
 
   const CodeCompletionResultType &getResultType() const { return ResultType; }
 
@@ -893,7 +874,11 @@ class ContextFreeCodeCompletionResult {
   CodeCompletionDiagnosticSeverity getDiagnosticSeverity() const {
     return DiagnosticSeverity;
   }
-  StringRef getDiagnosticMessage() const { return DiagnosticMessage; };
+  NullTerminatedStringRef getDiagnosticMessage() const {
+    return DiagnosticMessage;
+  }
+
+  NullTerminatedStringRef getFilterName() const { return FilterName; }
 
   bool isOperator() const {
     if (getKind() == CodeCompletionResultKind::Declaration) {
@@ -935,7 +920,7 @@ class CodeCompletionResult {
   CodeCompletionDiagnosticSeverity DiagnosticSeverity : 3;
   static_assert(int(CodeCompletionDiagnosticSeverity::MAX_VALUE) < 1 << 3, "");
 
-  StringRef DiagnosticMessage;
+  NullTerminatedStringRef DiagnosticMessage;
 
   /// The number of bytes to the left of the code completion point that
   /// should be erased first if this completion string is inserted in the
@@ -959,7 +944,7 @@ class CodeCompletionResult {
                        CodeCompletionResultTypeRelation TypeDistance,
                        ContextualNotRecommendedReason NotRecommended,
                        CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-                       StringRef DiagnosticMessage)
+                       NullTerminatedStringRef DiagnosticMessage)
       : ContextFree(ContextFree), SemanticContext(SemanticContext),
         Flair(Flair.toRaw()), NotRecommended(NotRecommended),
         DiagnosticSeverity(DiagnosticSeverity),
@@ -981,7 +966,7 @@ class CodeCompletionResult {
                        const DeclContext *DC,
                        ContextualNotRecommendedReason NotRecommended,
                        CodeCompletionDiagnosticSeverity DiagnosticSeverity,
-                       StringRef DiagnosticMessage);
+                       NullTerminatedStringRef DiagnosticMessage);
 
   const ContextFreeCodeCompletionResult &getContextFreeResult() const {
     return ContextFree;
@@ -1090,15 +1075,15 @@ class CodeCompletionResult {
     return getContextFreeResult().getCompletionString();
   }
 
-  StringRef getModuleName() const {
+  NullTerminatedStringRef getModuleName() const {
     return getContextFreeResult().getModuleName();
   }
 
-  StringRef getBriefDocComment() const {
+  NullTerminatedStringRef getBriefDocComment() const {
     return getContextFreeResult().getBriefDocComment();
   }
 
-  ArrayRef<StringRef> getAssociatedUSRs() const {
+  ArrayRef<NullTerminatedStringRef> getAssociatedUSRs() const {
     return getContextFreeResult().getAssociatedUSRs();
   }
 
@@ -1110,7 +1095,9 @@ class CodeCompletionResult {
 
   /// Get the contextual diagnostic message. This disregards context-free
   /// diagnostics.
-  StringRef getContextualDiagnosticMessage() const { return DiagnosticMessage; }
+  NullTerminatedStringRef getContextualDiagnosticMessage() const {
+    return DiagnosticMessage;
+  }
 
   /// Return the contextual diagnostic severity if there was a contextual
   /// diagnostic. If there is no contextual diagnostic, return the context-free
@@ -1126,14 +1113,18 @@ class CodeCompletionResult {
   /// Return the contextual diagnostic message if there was a contextual
   /// diagnostic. If there is no contextual diagnostic, return the context-free
   /// diagnostic message.
-  StringRef getDiagnosticMessage() const {
+  NullTerminatedStringRef getDiagnosticMessage() const {
     if (NotRecommended != ContextualNotRecommendedReason::None) {
       return DiagnosticMessage;
     } else {
       return getContextFreeResult().getDiagnosticMessage();
     }
   }
 
+  NullTerminatedStringRef getFilterName() const {
+    return getContextFreeResult().getFilterName();
+  }
+
   /// Print a debug representation of the code completion result to \p OS.
   void printPrefix(raw_ostream &OS) const;
   SWIFT_DEBUG_DUMP;
@@ -1169,7 +1160,7 @@ struct CodeCompletionResultSink {
 
   /// A single-element cache for module names stored in Allocator, keyed by a
   /// clang::Module * or swift::ModuleDecl *.
-  std::pair<void *, StringRef> LastModule;
+  std::pair<void *, NullTerminatedStringRef> LastModule;
 
   CodeCompletionResultSink()
       : Allocator(std::make_shared<llvm::BumpPtrAllocator>()) {}

include/swift/IDE/CodeCompletionResultPrinter.h

@@ -13,12 +13,18 @@
 #ifndef SWIFT_IDE_CODECOMPLETIONRESULTPRINTER_H
 #define SWIFT_IDE_CODECOMPLETIONRESULTPRINTER_H
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Allocator.h"
 
 namespace swift {
+
+class NullTerminatedStringRef;
+
 namespace ide {
 
 class CodeCompletionResult;
+class CodeCompletionString;
 
 void printCodeCompletionResultDescription(const CodeCompletionResult &Result,
                                           llvm::raw_ostream &OS,
@@ -37,8 +43,11 @@ void printCodeCompletionResultTypeNameAnnotated(
 void printCodeCompletionResultSourceText(
     const CodeCompletionResult &Result, llvm::raw_ostream &OS);
 
-void printCodeCompletionResultFilterName(
-    const CodeCompletionResult &Result, llvm::raw_ostream &OS);
+/// Print 'FilterName' from \p str into memory managed by \p Allocator and
+/// return it as \c NullTerminatedStringRef .
+NullTerminatedStringRef
+getCodeCompletionResultFilterName(const CodeCompletionString *Str,
+                                  llvm::BumpPtrAllocator &Allocator);
 
 } // namespace ide
 } // namespace swift