[sourcekit] Refactor notification handling layering

benlangmuir · benlangmuir · commit 152370e99653 · 2020-11-10T12:35:28.000-08:00
This refactors notification handling so that the XPC service and InProc
library pass in their notification handler callback. This fixes a
layering issue where the sourcekitd libraries could not be linked
dynamically due to the missing symbols.
diff --git a/tools/SourceKit/include/SourceKit/Core/NotificationCenter.h b/tools/SourceKit/include/SourceKit/Core/NotificationCenter.h
@@ -14,18 +14,33 @@
 #define LLVM_SOURCEKIT_CORE_NOTIFICATIONCENTER_H
 
 #include "SourceKit/Core/LLVM.h"
+#include "SourceKit/Support/Tracing.h"
+#include "SourceKit/Support/UIdent.h"
 #include "llvm/Support/Mutex.h"
 #include <functional>
 #include <vector>
 
 namespace SourceKit {
 
+struct DiagnosticEntryInfo;
+
 typedef std::function<void(StringRef DocumentName)>
     DocumentUpdateNotificationReceiver;
 
+typedef std::function<void(uint64_t CompileID, trace::OperationKind,
+                           const trace::SwiftInvocation &)>
+    CompileWillStartNotificationReceiver;
+typedef std::function<void(uint64_t CompileID, trace::OperationKind,
+                           ArrayRef<DiagnosticEntryInfo>)>
+    CompileDidFinishNotificationReceiver;
+
 class NotificationCenter {
   bool DispatchToMain;
   std::vector<DocumentUpdateNotificationReceiver> DocUpdReceivers;
+  std::vector<std::function<void(void)>> TestReceivers;
+  std::vector<std::function<void(void)>> SemaEnabledReceivers;
+  std::vector<CompileWillStartNotificationReceiver> CompileWillStartReceivers;
+  std::vector<CompileDidFinishNotificationReceiver> CompileDidFinishReceivers;
   mutable llvm::sys::Mutex Mtx;
 
 public:
@@ -34,8 +49,23 @@ class NotificationCenter {
 
   void addDocumentUpdateNotificationReceiver(
       DocumentUpdateNotificationReceiver Receiver);
+  void addTestNotificationReceiver(std::function<void(void)> Receiver);
+  void addSemaEnabledNotificationReceiver(std::function<void(void)> Receiver);
+  void addCompileWillStartNotificationReceiver(
+      CompileWillStartNotificationReceiver Receiver);
+  void addCompileDidFinishNotificationReceiver(
+      CompileDidFinishNotificationReceiver Receiver);
 
   void postDocumentUpdateNotification(StringRef DocumentName) const;
+  void postTestNotification() const;
+  void postSemaEnabledNotification() const;
+  void
+  postCompileWillStartNotification(uint64_t CompileID,
+                                   trace::OperationKind OpKind,
+                                   const trace::SwiftInvocation &Inv) const;
+  void postCompileDidFinishNotification(
+      uint64_t CompileID, trace::OperationKind OpKind,
+      ArrayRef<DiagnosticEntryInfo> Diagnostics) const;
 };
 
 } // namespace SourceKit
diff --git a/tools/SourceKit/lib/Core/NotificationCenter.cpp b/tools/SourceKit/lib/Core/NotificationCenter.cpp
@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SourceKit/Core/NotificationCenter.h"
+#include "SourceKit/Core/LangSupport.h"
 #include "SourceKit/Support/Concurrency.h"
 
 using namespace SourceKit;
@@ -27,21 +28,64 @@ void NotificationCenter::addDocumentUpdateNotificationReceiver(
   DocUpdReceivers.push_back(Receiver);
 }
 
+void NotificationCenter::addTestNotificationReceiver(
+    std::function<void(void)> Receiver) {
+  llvm::sys::ScopedLock L(Mtx);
+  TestReceivers.push_back(std::move(Receiver));
+}
+void NotificationCenter::addSemaEnabledNotificationReceiver(
+    std::function<void(void)> Receiver) {
+  llvm::sys::ScopedLock L(Mtx);
+  SemaEnabledReceivers.push_back(std::move(Receiver));
+}
+void NotificationCenter::addCompileWillStartNotificationReceiver(
+    CompileWillStartNotificationReceiver Receiver) {
+  llvm::sys::ScopedLock L(Mtx);
+  CompileWillStartReceivers.push_back(std::move(Receiver));
+}
+void NotificationCenter::addCompileDidFinishNotificationReceiver(
+    CompileDidFinishNotificationReceiver Receiver) {
+  llvm::sys::ScopedLock L(Mtx);
+  CompileDidFinishReceivers.push_back(std::move(Receiver));
+}
+
+#define POST_NOTIFICATION(Receivers, Args...)                                  \
+  do {                                                                         \
+    decltype(Receivers) recvs;                                                 \
+    {                                                                          \
+      llvm::sys::ScopedLock L(Mtx);                                            \
+      recvs = Receivers;                                                       \
+    }                                                                          \
+    auto sendNote = [=] {                                                      \
+      for (auto &Fn : recvs)                                                   \
+        Fn(Args);                                                              \
+    };                                                                         \
+    if (DispatchToMain)                                                        \
+      WorkQueue::dispatchOnMain(sendNote);                                     \
+    else                                                                       \
+      sendNote();                                                              \
+  } while (0)
+
 void NotificationCenter::postDocumentUpdateNotification(
     StringRef DocumentName) const {
-
-  std::vector<DocumentUpdateNotificationReceiver> recvs;
-  {
-    llvm::sys::ScopedLock L(Mtx);
-    recvs = DocUpdReceivers;
-  }
   std::string docName = DocumentName.str();
-  auto sendNote = [recvs, docName]{
-    for (auto &Fn : recvs)
-      Fn(docName);
-  };
-  if (DispatchToMain)
-    WorkQueue::dispatchOnMain(sendNote);
-  else
-    sendNote();
+  POST_NOTIFICATION(DocUpdReceivers, docName);
+}
+void NotificationCenter::postTestNotification() const {
+  POST_NOTIFICATION(TestReceivers, );
+}
+void NotificationCenter::postSemaEnabledNotification() const {
+  POST_NOTIFICATION(SemaEnabledReceivers, );
+}
+void NotificationCenter::postCompileWillStartNotification(
+    uint64_t CompileID, trace::OperationKind OpKind,
+    const trace::SwiftInvocation &Inv) const {
+  trace::SwiftInvocation inv(Inv);
+  POST_NOTIFICATION(CompileWillStartReceivers, CompileID, OpKind, inv);
+}
+void NotificationCenter::postCompileDidFinishNotification(
+    uint64_t CompileID, trace::OperationKind OpKind,
+    ArrayRef<DiagnosticEntryInfo> Diagnostics) const {
+  std::vector<DiagnosticEntryInfo> diags(Diagnostics);
+  POST_NOTIFICATION(CompileDidFinishReceivers, CompileID, OpKind, diags);
 }
diff --git a/tools/SourceKit/tools/sourcekitd/bin/InProc/sourcekitdInProc.cpp b/tools/SourceKit/tools/sourcekitd/bin/InProc/sourcekitdInProc.cpp
@@ -13,6 +13,7 @@
 #include "sourcekitd/Internal.h"
 
 #include "SourceKit/Support/Concurrency.h"
+#include "SourceKit/Support/Logging.h"
 #include "SourceKit/Support/UIdent.h"
 
 #include "llvm/ADT/SmallString.h"
@@ -36,6 +37,8 @@ static llvm::sys::Mutex GlobalHandlersMtx;
 static sourcekitd_uid_handler_t UidMappingHandler;
 static sourcekitd_str_from_uid_handler_t StrFromUidMappingHandler;
 
+static void postNotification(sourcekitd_response_t Notification);
+
 void
 sourcekitd_set_uid_handler(sourcekitd_uid_handler_t handler) {
   llvm::sys::ScopedLock L(GlobalHandlersMtx);
@@ -106,20 +109,36 @@ static void getToolchainPrefixPath(llvm::SmallVectorImpl<char> &Path) {
 #endif
 }
 
-std::string sourcekitd::getRuntimeLibPath() {
+static std::string getRuntimeLibPath() {
   llvm::SmallString<128> libPath;
   getToolchainPrefixPath(libPath);
   llvm::sys::path::append(libPath, "lib");
   return libPath.str().str();
 }
 
-std::string sourcekitd::getDiagnosticDocumentationPath() {
+static std::string getDiagnosticDocumentationPath() {
   llvm::SmallString<128> docPath;
   getToolchainPrefixPath(docPath);
   llvm::sys::path::append(docPath, "share", "doc", "swift", "diagnostics");
   return docPath.str().str();
 }
 
+void sourcekitd_initialize(void) {
+  if (sourcekitd::initializeClient()) {
+    LOG_INFO_FUNC(High, "initializing");
+    sourcekitd::initializeService(getRuntimeLibPath(),
+                                  getDiagnosticDocumentationPath(),
+                                  postNotification);
+  }
+}
+
+void sourcekitd_shutdown(void) {
+  if (sourcekitd::shutdownClient()) {
+    LOG_INFO_FUNC(High, "shutting down");
+    sourcekitd::shutdownService();
+  }
+}
+
 void sourcekitd::set_interrupted_connection_handler(
                           llvm::function_ref<void()> handler) {
 }
@@ -179,7 +198,7 @@ sourcekitd_set_notification_handler(sourcekitd_response_receiver_t receiver) {
   });
 }
 
-void sourcekitd::postNotification(sourcekitd_response_t Notification) {
+void postNotification(sourcekitd_response_t Notification) {
   WorkQueue::dispatchOnMain([=]{
     if (!NotificationReceiver) {
       sourcekitd_response_dispose(Notification);
diff --git a/tools/SourceKit/tools/sourcekitd/bin/XPC/Client/sourcekitd.cpp b/tools/SourceKit/tools/sourcekitd/bin/XPC/Client/sourcekitd.cpp
@@ -240,7 +240,7 @@ static void handleInternalUIDRequest(xpc_object_t XVal,
 
 static void handleInterruptedConnection(xpc_object_t event, xpc_connection_t conn);
 
-void sourcekitd::initialize() {
+static void initializeXPCClient() {
   assert(!GlobalConn);
   GlobalConn = xpc_connection_create(SOURCEKIT_XPCSERVICE_IDENTIFIER, nullptr);
 
@@ -309,9 +309,19 @@ void sourcekitd::initialize() {
   xpc_connection_resume(GlobalConn);
 }
 
-void sourcekitd::shutdown() {
-  assert(GlobalConn);
-  xpc_connection_cancel(GlobalConn);
+void sourcekitd_initialize(void) {
+  if (sourcekitd::initializeClient()) {
+    LOG_INFO_FUNC(High, "initializing");
+    initializeXPCClient();
+  }
+}
+
+void sourcekitd_shutdown(void) {
+  if (sourcekitd::shutdownClient()) {
+    LOG_INFO_FUNC(High, "shutting down");
+    assert(GlobalConn);
+    xpc_connection_cancel(GlobalConn);
+  }
 }
 
 static xpc_connection_t getGlobalConnection() {
diff --git a/tools/SourceKit/tools/sourcekitd/bin/XPC/Service/XPCService.cpp b/tools/SourceKit/tools/sourcekitd/bin/XPC/Service/XPCService.cpp
@@ -32,7 +32,7 @@ using namespace sourcekitd;
 
 static xpc_connection_t MainConnection = nullptr;
 
-void sourcekitd::postNotification(sourcekitd_response_t Notification) {
+static void postNotification(sourcekitd_response_t Notification) {
   xpc_connection_t peer = MainConnection;
   if (!peer)
     goto done;
@@ -208,14 +208,14 @@ static void getToolchainPrefixPath(llvm::SmallVectorImpl<char> &Path) {
     llvm::sys::path::remove_filename(Path);
 }
 
-std::string sourcekitd::getRuntimeLibPath() {
+static std::string getRuntimeLibPath() {
   llvm::SmallString<128> path;
   getToolchainPrefixPath(path);
   llvm::sys::path::append(path, "lib");
   return path.str().str();
 }
 
-std::string sourcekitd::getDiagnosticDocumentationPath() {
+static std::string getDiagnosticDocumentationPath() {
   llvm::SmallString<128> path;
   getToolchainPrefixPath(path);
   llvm::sys::path::append(path, "share", "doc", "swift", "diagnostics");
@@ -341,7 +341,8 @@ static void fatal_error_handler(void *user_data, const std::string& reason,
 int main(int argc, const char *argv[]) {
   llvm::install_fatal_error_handler(fatal_error_handler, 0);
   sourcekitd::enableLogging("sourcekit-serv");
-  sourcekitd::initialize();
+  sourcekitd::initializeService(
+      getRuntimeLibPath(), getDiagnosticDocumentationPath(), postNotification);
 
   // Increase the file descriptor limit.
   // FIXME: Portability ?
diff --git a/tools/SourceKit/tools/sourcekitd/include/sourcekitd/Internal.h b/tools/SourceKit/tools/sourcekitd/include/sourcekitd/Internal.h
@@ -149,8 +149,23 @@ class RequestDict {
   Optional<int64_t> getOptionalInt64(SourceKit::UIdent Key);
 };
 
-void initialize();
-void shutdown();
+/// Initialize the service. Must be called before attempting to handle requests.
+/// \param runtimeLibPath The path to the toolchain's library directory.
+/// \param diagnosticDocumentationPath The path to diagnostics documentation.
+/// \param postNotification Callback to post a notification.
+void initializeService(
+    llvm::StringRef runtimeLibPath, llvm::StringRef diagnosticDocumentationPath,
+    std::function<void(sourcekitd_response_t)> postNotification);
+/// Shutdown the service.
+void shutdownService();
+
+/// Initialize the sourcekitd client library. Returns true if this is the first
+/// time it is initialized.
+bool initializeClient();
+/// Shutdown the sourcekitd client. Returns true if this is the last active
+/// client and the service should be shutdown.
+bool shutdownClient();
+
 void set_interrupted_connection_handler(llvm::function_ref<void()> handler);
 
 typedef std::function<void(sourcekitd_response_t)> ResponseReceiver;
@@ -165,17 +180,10 @@ sourcekitd_response_t createErrorRequestFailed(llvm::StringRef Description);
 sourcekitd_response_t createErrorRequestInterrupted(llvm::StringRef Descr);
 sourcekitd_response_t createErrorRequestCancelled();
 
-/// Send notification object.
-/// The ownership of the object is transferred to the function.
-void postNotification(sourcekitd_response_t Notification);
-
 // The client & service have their own implementations for these.
 sourcekitd_uid_t SKDUIDFromUIdent(SourceKit::UIdent UID);
 SourceKit::UIdent UIdentFromSKDUID(sourcekitd_uid_t uid);
 
-std::string getRuntimeLibPath();
-std::string getDiagnosticDocumentationPath();
-
 void writeEscaped(llvm::StringRef Str, llvm::raw_ostream &OS);
 
 static inline sourcekitd_variant_t makeNullVariant() {
diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/Requests.cpp
diff --git a/tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-Common.cpp b/tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-Common.cpp
