Split IDEInspectionCallbacks into CodeCompletionCallbacks and DoneParsingCallback

Cursor info only cares about the `doneParsing` callback and not about all the `complete` functions that are now defined in `CodeCompletionCallbacks`. To make the design clearer, split `IDEInspectionCallbacks`.

rdar://105120332

Author: ahoppen

include/swift/IDE/CompletionLookup.h

@@ -614,7 +614,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void collectPrecedenceGroups();
 
   void getPrecedenceGroupCompletions(
-      IDEInspectionCallbacks::PrecedenceGroupCompletionKind SK);
+      CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK);
 
   void getPoundAvailablePlatformCompletions();
 

include/swift/Parse/IDEInspectionCallbacks.h

@@ -30,7 +30,7 @@ enum class ObjCSelectorContext {
 };
 
 /// Parser's interface to code completion.
-class IDEInspectionCallbacks {
+class CodeCompletionCallbacks {
 protected:
   Parser &P;
   ASTContext &Context;
@@ -55,11 +55,9 @@ class IDEInspectionCallbacks {
   std::vector<Expr *> leadingSequenceExprs;
 
 public:
-  IDEInspectionCallbacks(Parser &P)
-      : P(P), Context(P.Context) {
-  }
+  CodeCompletionCallbacks(Parser &P) : P(P), Context(P.Context) {}
 
-  virtual ~IDEInspectionCallbacks() {}
+  virtual ~CodeCompletionCallbacks() {}
 
   bool isInsideObjCSelector() const {
     return CompleteExprSelectorContext != ObjCSelectorContext::None;
@@ -81,10 +79,10 @@ class IDEInspectionCallbacks {
   }
 
   class InEnumElementRawValueRAII {
-    IDEInspectionCallbacks *Callbacks;
+    CodeCompletionCallbacks *Callbacks;
 
   public:
-    InEnumElementRawValueRAII(IDEInspectionCallbacks *Callbacks)
+    InEnumElementRawValueRAII(CodeCompletionCallbacks *Callbacks)
         : Callbacks(Callbacks) {
       if (Callbacks)
         Callbacks->InEnumElementRawValue = true;
@@ -99,10 +97,10 @@ class IDEInspectionCallbacks {
   /// RAII type that temporarily sets the "in Objective-C #selector expression"
   /// flag on the code completion callbacks object.
   class InObjCSelectorExprRAII {
-    IDEInspectionCallbacks *Callbacks;
+    CodeCompletionCallbacks *Callbacks;
 
   public:
-    InObjCSelectorExprRAII(IDEInspectionCallbacks *Callbacks,
+    InObjCSelectorExprRAII(CodeCompletionCallbacks *Callbacks,
                            ObjCSelectorContext SelectorContext)
         : Callbacks(Callbacks) {
       if (Callbacks)
@@ -251,20 +249,31 @@ class IDEInspectionCallbacks {
   virtual void completeTypeAttrBeginning() {};
 
   virtual void completeOptionalBinding(){};
+};
+
+class DoneParsingCallback {
+public:
+  virtual ~DoneParsingCallback() {}
 
   /// Signals that the AST for the all the delayed-parsed code was
   /// constructed.  No \c complete*() callbacks will be done after this.
   virtual void doneParsing(SourceFile *SrcFile) = 0;
 };
 
-/// A factory to create instances of \c IDEInspectionCallbacks.
+/// A factory to create instances of \c CodeCompletionCallbacks and
+/// \c DoneParsingCallback.
 class IDEInspectionCallbacksFactory {
 public:
   virtual ~IDEInspectionCallbacksFactory() {}
 
+  struct Callbacks {
+    std::shared_ptr<CodeCompletionCallbacks> CompletionCallbacks;
+    std::shared_ptr<DoneParsingCallback> DoneParsingCallback;
+  };
+
   /// Create an instance of \c IDEInspectionCallbacks.  The result
   /// should be deallocated with 'delete'.
-  virtual IDEInspectionCallbacks *createIDEInspectionCallbacks(Parser &P) = 0;
+  virtual Callbacks createCallbacks(Parser &P) = 0;
 };
 
 } // namespace swift

include/swift/Parse/Parser.h

@@ -41,7 +41,8 @@ namespace llvm {
 
 namespace swift {
   class IdentTypeRepr;
-  class IDEInspectionCallbacks;
+  class CodeCompletionCallbacks;
+  class DoneParsingCallback;
   class IDEInspectionCallbacksFactory;
   class DefaultArgumentInitializer;
   class DiagnosticEngine;
@@ -129,7 +130,8 @@ class Parser {
   std::unique_ptr<PersistentParserState> OwnedState;
   DeclContext *CurDeclContext;
   ASTContext &Context;
-  IDEInspectionCallbacks *IDECallbacks = nullptr;
+  CodeCompletionCallbacks *CodeCompletionCallbacks = nullptr;
+  DoneParsingCallback *DoneParsingCallback = nullptr;
   std::vector<Located<std::vector<ParamDecl*>>> AnonClosureVars;
 
   /// The current token hash, or \c None if the parser isn't computing a hash
@@ -163,12 +165,16 @@ class Parser {
   /// the #if decl.
   bool shouldEvaluatePoundIfDecls() const;
 
-  void setIDECallbacks(IDEInspectionCallbacks *Callbacks) {
-    IDECallbacks = Callbacks;
+  void setCodeCompletionCallbacks(class CodeCompletionCallbacks *Callbacks) {
+    CodeCompletionCallbacks = Callbacks;
+  }
+
+  void setDoneParsingCallback(class DoneParsingCallback *Callback) {
+    this->DoneParsingCallback = Callback;
   }
 
   bool isIDEInspectionFirstPass() const {
-    return SourceMgr.hasIDEInspectionTargetBuffer() && !IDECallbacks;
+    return SourceMgr.hasIDEInspectionTargetBuffer() && !DoneParsingCallback;
   }
 
   bool allowTopLevelCode() const;

lib/IDE/CodeCompletion.cpp

@@ -103,7 +103,8 @@ std::string swift::ide::removeCodeCompletionTokens(
 
 namespace {
 
-class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
+class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
+                                    public DoneParsingCallback {
   CodeCompletionContext &CompletionContext;
   CodeCompletionConsumer &Consumer;
   CodeCompletionExpr *CodeCompleteTokenExpr = nullptr;
@@ -123,7 +124,7 @@ class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
   /// In situations when \c SyntaxKind hints or determines
   /// completions, i.e. a precedence group attribute, this
   /// can be set and used to control the code completion scenario.
-  IDEInspectionCallbacks::PrecedenceGroupCompletionKind SyntxKind;
+  CodeCompletionCallbacks::PrecedenceGroupCompletionKind SyntxKind;
 
   int AttrParamIndex;
   bool IsInSil = false;
@@ -233,9 +234,8 @@ class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
   CodeCompletionCallbacksImpl(Parser &P,
                               CodeCompletionContext &CompletionContext,
                               CodeCompletionConsumer &Consumer)
-      : IDEInspectionCallbacks(P), CompletionContext(CompletionContext),
-        Consumer(Consumer) {
-  }
+      : CodeCompletionCallbacks(P), DoneParsingCallback(),
+        CompletionContext(CompletionContext), Consumer(Consumer) {}
 
   void setAttrTargetDeclKind(Optional<DeclKind> DK) override {
     if (DK == DeclKind::PatternBinding)
@@ -273,7 +273,7 @@ class CodeCompletionCallbacksImpl : public IDEInspectionCallbacks {
   void completeDeclAttrParam(DeclAttrKind DK, int Index) override;
   void completeEffectsSpecifier(bool hasAsync, bool hasThrows) override;
   void completeInPrecedenceGroup(
-      IDEInspectionCallbacks::PrecedenceGroupCompletionKind SK) override;
+      CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) override;
   void completeNominalMemberBeginning(
       SmallVectorImpl<StringRef> &Keywords, SourceLoc introducerLoc) override;
   void completeAccessorBeginning(CodeCompletionExpr *E) override;
@@ -484,7 +484,7 @@ void CodeCompletionCallbacksImpl::completeDeclAttrBeginning(
 }
 
 void CodeCompletionCallbacksImpl::completeInPrecedenceGroup(
-    IDEInspectionCallbacks::PrecedenceGroupCompletionKind SK) {
+    CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) {
   assert(P.Tok.is(tok::code_complete));
 
   SyntxKind = SK;
@@ -1480,7 +1480,7 @@ bool CodeCompletionCallbacksImpl::trySolverCompletion(bool MaybeFuncBody) {
   case CompletionKind::KeyPathExprSwift: {
     assert(CurDeclContext);
 
-    // IDEInspectionCallbacks::completeExprKeyPath takes a \c KeyPathExpr,
+    // CodeCompletionCallbacks::completeExprKeyPath takes a \c KeyPathExpr,
     // so we can safely cast the \c ParsedExpr back to a \c KeyPathExpr.
     auto KeyPath = cast<KeyPathExpr>(ParsedExpr);
     KeyPathTypeCheckCompletionCallback Lookup(KeyPath);
@@ -2040,8 +2040,10 @@ class CodeCompletionCallbacksFactoryImpl
                                      CodeCompletionConsumer &Consumer)
       : CompletionContext(CompletionContext), Consumer(Consumer) {}
 
-      IDEInspectionCallbacks *createIDEInspectionCallbacks(Parser &P) override {
-    return new CodeCompletionCallbacksImpl(P, CompletionContext, Consumer);
+  Callbacks createCallbacks(Parser &P) override {
+    auto callbacks = std::make_shared<CodeCompletionCallbacksImpl>(
+        P, CompletionContext, Consumer);
+    return {callbacks, callbacks};
   }
 };
 } // end anonymous namespace

lib/IDE/CompletionLookup.cpp

@@ -3049,26 +3049,26 @@ void CompletionLookup::collectPrecedenceGroups() {
 }
 
 void CompletionLookup::getPrecedenceGroupCompletions(
-    IDEInspectionCallbacks::PrecedenceGroupCompletionKind SK) {
+    CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) {
   switch (SK) {
-  case IDEInspectionCallbacks::PrecedenceGroupCompletionKind::Associativity:
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::Associativity:
     addKeyword(getAssociativitySpelling(Associativity::None));
     addKeyword(getAssociativitySpelling(Associativity::Left));
     addKeyword(getAssociativitySpelling(Associativity::Right));
     return;
-  case IDEInspectionCallbacks::PrecedenceGroupCompletionKind::Assignment:
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::Assignment:
     addKeyword(getTokenText(tok::kw_false), Type(), SemanticContextKind::None,
                CodeCompletionKeywordKind::kw_false);
     addKeyword(getTokenText(tok::kw_true), Type(), SemanticContextKind::None,
                CodeCompletionKeywordKind::kw_true);
     return;
-  case IDEInspectionCallbacks::PrecedenceGroupCompletionKind::AttributeList:
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::AttributeList:
     addKeyword("associativity");
     addKeyword("higherThan");
     addKeyword("lowerThan");
     addKeyword("assignment");
     return;
-  case IDEInspectionCallbacks::PrecedenceGroupCompletionKind::Relation:
+  case CodeCompletionCallbacks::PrecedenceGroupCompletionKind::Relation:
     collectPrecedenceGroups();
     return;
   }

lib/IDE/ConformingMethodList.cpp

@@ -25,7 +25,8 @@ using namespace swift;
 using namespace ide;
 
 namespace {
-class ConformingMethodListCallbacks : public IDEInspectionCallbacks {
+class ConformingMethodListCallbacks : public CodeCompletionCallbacks,
+                                      public DoneParsingCallback {
   ArrayRef<const char *> ExpectedTypeNames;
   ConformingMethodListConsumer &Consumer;
   SourceLoc Loc;
@@ -40,8 +41,8 @@ class ConformingMethodListCallbacks : public IDEInspectionCallbacks {
   ConformingMethodListCallbacks(Parser &P,
                                 ArrayRef<const char *> ExpectedTypeNames,
                                 ConformingMethodListConsumer &Consumer)
-      : IDEInspectionCallbacks(P), ExpectedTypeNames(ExpectedTypeNames),
-        Consumer(Consumer) {}
+      : CodeCompletionCallbacks(P), DoneParsingCallback(),
+        ExpectedTypeNames(ExpectedTypeNames), Consumer(Consumer) {}
 
   // Only handle callbacks for suffix completions.
   // {
@@ -190,8 +191,10 @@ swift::ide::makeConformingMethodListCallbacksFactory(
         ConformingMethodListConsumer &Consumer)
         : ExpectedTypeNames(ExpectedTypeNames), Consumer(Consumer) {}
 
-    IDEInspectionCallbacks *createIDEInspectionCallbacks(Parser &P) override {
-      return new ConformingMethodListCallbacks(P, ExpectedTypeNames, Consumer);
+    Callbacks createCallbacks(Parser &P) override {
+      auto Callback = std::make_shared<ConformingMethodListCallbacks>(
+          P, ExpectedTypeNames, Consumer);
+      return {Callback, Callback};
     }
   };
 

lib/IDE/CursorInfo.cpp

@@ -318,15 +318,14 @@ class CursorInfoTypeCheckSolutionCallback : public TypeCheckCompletionCallback {
 
 // MARK: - CursorInfoDoneParsingCallback
 
-class CursorInfoDoneParsingCallback : public IDEInspectionCallbacks {
+class CursorInfoDoneParsingCallback : public DoneParsingCallback {
   CursorInfoConsumer &Consumer;
   SourceLoc RequestedLoc;
 
 public:
   CursorInfoDoneParsingCallback(Parser &P, CursorInfoConsumer &Consumer,
                                 SourceLoc RequestedLoc)
-      : IDEInspectionCallbacks(P), Consumer(Consumer),
-        RequestedLoc(RequestedLoc) {}
+      : DoneParsingCallback(), Consumer(Consumer), RequestedLoc(RequestedLoc) {}
 
   ResolvedCursorInfoPtr getDeclResult(NodeFinderDeclResult *DeclResult,
                                       SourceFile *SrcFile,
@@ -439,8 +438,10 @@ swift::ide::makeCursorInfoCallbacksFactory(CursorInfoConsumer &Consumer,
                                    SourceLoc RequestedLoc)
         : Consumer(Consumer), RequestedLoc(RequestedLoc) {}
 
-    IDEInspectionCallbacks *createIDEInspectionCallbacks(Parser &P) override {
-      return new CursorInfoDoneParsingCallback(P, Consumer, RequestedLoc);
+    Callbacks createCallbacks(Parser &P) override {
+      auto Callback = std::make_shared<CursorInfoDoneParsingCallback>(
+          P, Consumer, RequestedLoc);
+      return {nullptr, Callback};
     }
   };
 

lib/IDE/TypeContextInfo.cpp

@@ -26,7 +26,8 @@
 using namespace swift;
 using namespace ide;
 
-class ContextInfoCallbacks : public IDEInspectionCallbacks {
+class ContextInfoCallbacks : public CodeCompletionCallbacks,
+                             public DoneParsingCallback {
   TypeContextInfoConsumer &Consumer;
   SourceLoc Loc;
   Expr *ParsedExpr = nullptr;
@@ -36,7 +37,7 @@ class ContextInfoCallbacks : public IDEInspectionCallbacks {
 
 public:
   ContextInfoCallbacks(Parser &P, TypeContextInfoConsumer &Consumer)
-      : IDEInspectionCallbacks(P), Consumer(Consumer) {}
+      : CodeCompletionCallbacks(P), DoneParsingCallback(), Consumer(Consumer) {}
 
   void completePostfixExprBeginning(CodeCompletionExpr *E) override;
   void completeForEachSequenceBeginning(CodeCompletionExpr *E) override;
@@ -211,8 +212,9 @@ IDEInspectionCallbacksFactory *swift::ide::makeTypeContextInfoCallbacksFactory(
     ContextInfoCallbacksFactoryImpl(TypeContextInfoConsumer &Consumer)
         : Consumer(Consumer) {}
 
-    IDEInspectionCallbacks *createIDEInspectionCallbacks(Parser &P) override {
-      return new ContextInfoCallbacks(P, Consumer);
+    Callbacks createCallbacks(Parser &P) override {
+      auto Callbacks = std::make_shared<ContextInfoCallbacks>(P, Consumer);
+      return {Callbacks, Callbacks};
     }
   };