[SwiftScan] Add SwiftScan APIs to replay the cache output

Add new C APIs to libSwiftScan for cache querying and cache replays.

Author: cachemeifyoucan

include/swift-c/DependencyScan/DependencyScan.h

@@ -25,7 +25,7 @@
 /// SWIFTSCAN_VERSION_MINOR should increase when there are API additions.
 /// SWIFTSCAN_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
 #define SWIFTSCAN_VERSION_MAJOR 0
-#define SWIFTSCAN_VERSION_MINOR 5
+#define SWIFTSCAN_VERSION_MINOR 6
 
 SWIFTSCAN_BEGIN_DECLS
 
@@ -437,17 +437,44 @@ typedef struct swiftscan_cas_options_s *swiftscan_cas_options_t;
 /// ActionCache.
 typedef struct swiftscan_cas_s *swiftscan_cas_t;
 
+/// Opaque type for a cancellation token for async cache operations.
+typedef struct swiftscan_cache_cancellation_token_s
+    *swiftscan_cache_cancellation_token_t;
+
 /// Enum types for output types for cache key computation.
-/// TODO: complete the list.
+/// List should contain all the output file types, including supplemententary
+/// outputs, except diagnostics outputs, which are covered by cached diagnostic
+/// entry.
 typedef enum {
   SWIFTSCAN_OUTPUT_TYPE_OBJECT = 0,
   SWIFTSCAN_OUTPUT_TYPE_SWIFTMODULE = 1,
   SWIFTSCAN_OUTPUT_TYPE_SWIFTINTERFACE = 2,
   SWIFTSCAN_OUTPUT_TYPE_SWIFTPRIVATEINTERFACE = 3,
   SWIFTSCAN_OUTPUT_TYPE_CLANG_MODULE = 4,
-  SWIFTSCAN_OUTPUT_TYPE_CLANG_PCH = 5
+  SWIFTSCAN_OUTPUT_TYPE_CLANG_PCH = 5,
+  SWIFTSCAN_OUTPUT_TYPE_CLANG_HEADER = 6,
+  SWIFTSCAN_OUTPUT_TYPE_SWIFT_SOURCE_INFO = 7,
+  SWIFTSCAN_OUTPUT_TYPE_SWIFT_MODULE_DOC = 8,
+  SWIFTSCAN_OUTPUT_TYPE_DEPENDENCIES = 9,
+  SWIFTSCAN_OUTPUT_TYPE_SWIFT_DEPS = 10,
+  SWIFTSCAN_OUTPUT_TYPE_MODULE_TRACE = 11,
+  SWIFTSCAN_OUTPUT_TYPE_TBD = 12,
+  SWIFTSCAN_OUTPUT_TYPE_SWIFT_MODULE_SUMMARY = 13,
+  SWIFTSCAN_OUTPUT_TYPE_SWIFT_ABI_DESCRIPTOR = 14,
+  SWIFTSCAN_OUTPUT_TYPE_CONST_VALUE = 15,
+  SWIFTSCAN_OUTPUT_TYPE_MODULE_SEMANTIC_INFO = 16,
+  SWIFTSCAN_OUTPUT_TYPE_YAML_OPT_RECORD = 17,
+  SWIFTSCAN_OUTPUT_TYPE_BITSTREAM_OPT_RECORD = 18,
+  SWIFTSCAN_OUTPUT_TYPE_CACHED_DIAGNOSTICS = 19
 } swiftscan_output_kind_t;
 
+/// Enum types for cache result lookup or replay.
+typedef enum {
+  SWIFTSCAN_CACHE_RESULT_SUCCESS = 0,
+  SWIFTSCAN_CACHE_RESULT_NOT_FOUND = 1,
+  SWIFTSCAN_CACHE_RESULT_ERROR = 2,
+} swiftscan_cache_result_t;
+
 /// Create a \c CASOptions for creating CAS inside scanner specified.
 SWIFTSCAN_PUBLIC swiftscan_cas_options_t swiftscan_cas_options_create(void);
 
@@ -497,6 +524,69 @@ SWIFTSCAN_PUBLIC swiftscan_string_ref_t swiftscan_compute_cache_key(
     swiftscan_cas_t cas, int argc, const char **argv, const char *input,
     swiftscan_output_kind_t kind, swiftscan_string_ref_t *error);
 
+/// Query the result of the compilation using the output cache key. \c globally
+/// suggests if the lookup should check remote cache if such operation exists.
+/// If remote cache is checked and result is found, the output is materialized
+/// locally so that later replay action should not require remote actions.
+/// If the return value is SWIFTSCAN_CACHE_RESULT_ERROR, the error message is
+/// returned via \c error parameter and it caller needs to free the message
+/// using `swiftscan_string_dispose`.
+SWIFTSCAN_PUBLIC swiftscan_cache_result_t
+swiftscan_cache_query(swiftscan_cas_t cas, const char *key, bool globally,
+                      swiftscan_string_ref_t *error);
+
+/// Async version of `swiftscan_cache_query` where result is returned via
+/// callback. \c ctx is an opaque value that passed to the callback and
+/// \c swiftscan_cache_cancellation_token_t will return an token that can be
+/// used to cancel the async operation. The token needs to be freed by caller
+/// using `swiftscan_cache_cancellation_token_dispose`.
+SWIFTSCAN_PUBLIC void swiftscan_cache_query_async(
+    swiftscan_cas_t cas, const char *key, bool globally, void *ctx,
+    void (*callback)(void *ctx, swiftscan_cache_result_t,
+                     swiftscan_string_ref_t error),
+    swiftscan_cache_cancellation_token_t *);
+
+/// Make the cache compilation available globally. \c callback will be called
+/// on completion.
+/// \c swiftscan_cache_cancellation_token_t will return an token that can be
+/// used to cancel the async operation. The token needs to be freed by caller
+/// using `swiftscan_cache_cancellation_token_dispose`.
+SWIFTSCAN_PUBLIC void swiftscan_cache_make_global_async(
+    swiftscan_cas_t cas, const char *key, void *ctx,
+    void (*callback)(void *ctx, swiftscan_string_ref_t error),
+    swiftscan_cache_cancellation_token_t *);
+
+/// Cancel the async cache action that is associated with token.
+SWIFTSCAN_PUBLIC void
+    swiftscan_cache_action_cancel(swiftscan_cache_cancellation_token_t);
+
+/// Dispose the cancellation token.
+SWIFTSCAN_PUBLIC void swiftscan_cache_cancellation_token_dispose(
+    swiftscan_cache_cancellation_token_t);
+
+/// Replay the cached compilation using command-line.
+/// If the return value is SWIFTSCAN_CACHE_RESULT_ERROR, the error message is
+/// returned via \c error parameter and it caller needs to free the message
+/// using `swiftscan_string_dispose`.
+SWIFTSCAN_PUBLIC swiftscan_cache_result_t swiftscan_cache_replay_compilation(
+    swiftscan_cas_t cas, int argc, const char **argv,
+    swiftscan_string_ref_t *error);
+
+
+/// Async replay the cached compilation. Callback function will be provided
+/// by the cache replay result, and its stdout, stderr, and any error message.
+/// \c ctx is an opaque value that passed to the callback and
+/// \c swiftscan_cache_cancellation_token_t will return an token that can be
+/// used to cancel the async operation. The token needs to be freed by caller
+/// using `swiftscan_cache_cancellation_token_dispose`.
+SWIFTSCAN_PUBLIC void swiftscan_cache_replay_compilation_async(
+    swiftscan_cas_t cas, int argc, const char **argv, void *ctx,
+    void (*callback)(void *ctx, swiftscan_cache_result_t,
+                     swiftscan_string_ref_t std_out,
+                     swiftscan_string_ref_t std_err,
+                     swiftscan_string_ref_t error),
+    swiftscan_cache_cancellation_token_t *);
+
 //===----------------------------------------------------------------------===//
 
 SWIFTSCAN_END_DECLS

include/swift/FrontendTool/FrontendTool.h

@@ -19,6 +19,7 @@
 #define SWIFT_FRONTENDTOOL_H
 
 #include "swift/Basic/LLVM.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 class Module;
@@ -76,7 +77,8 @@ StringRef escapeForMake(StringRef raw, llvm::SmallVectorImpl<char> &buffer);
 int performFrontend(ArrayRef<const char *> args,
                     const char *argv0,
                     void *mainAddr,
-                    FrontendObserver *observer = nullptr);
+                    FrontendObserver *observer = nullptr,
+                    llvm::raw_ostream &OS = llvm::errs());
 
 bool performCompileStepsPostSema(CompilerInstance &Instance, int &ReturnValue,
                                  FrontendObserver *observer);

lib/FrontendTool/FrontendTool.cpp

@@ -2077,9 +2077,9 @@ class PrettyStackTraceFrontend : public llvm::PrettyStackTraceEntry {
   };
 };
 
-int swift::performFrontend(ArrayRef<const char *> Args,
-                           const char *Argv0, void *MainAddr,
-                           FrontendObserver *observer) {
+int swift::performFrontend(ArrayRef<const char *> Args, const char *Argv0,
+                           void *MainAddr, FrontendObserver *observer,
+                           llvm::raw_ostream &OS) {
   INITIALIZE_LLVM();
   llvm::setBugReportMsg(SWIFT_CRASH_BUG_REPORT_MESSAGE "\n");
   llvm::EnablePrettyStackTraceOnSigInfoForThisThread();
@@ -2261,7 +2261,7 @@ int swift::performFrontend(ArrayRef<const char *> Args,
     PDC.setSuppressOutput(true);
   }
 
-  auto emitParseableBeganMessage = [&Invocation, &Args]() {
+  auto emitParseableBeganMessage = [&Invocation, &Args, &OS]() {
     const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
     const auto OSPid = getpid();
     const auto ProcInfo = sys::TaskProcessInformation(OSPid);
@@ -2276,7 +2276,7 @@ int swift::performFrontend(ArrayRef<const char *> Args,
       IO.forEachPrimaryInputWithIndex([&](const InputFile &Input,
                                           unsigned idx) -> bool {
         ArrayRef<InputFile> Inputs(Input);
-        emitBeganMessage(llvm::errs(),
+        emitBeganMessage(OS,
                          mapFrontendInvocationToAction(Invocation),
                          constructDetailedTaskDescription(Invocation,
                                                           Inputs,
@@ -2286,15 +2286,15 @@ int swift::performFrontend(ArrayRef<const char *> Args,
       });
     } else {
       // If no primary inputs are present, we are in WMO.
-      emitBeganMessage(llvm::errs(),
+      emitBeganMessage(OS,
                        mapFrontendInvocationToAction(Invocation),
                        constructDetailedTaskDescription(Invocation, IO.getAllInputs(), Args),
                        OSPid, ProcInfo);
     }
   };
 
-  auto emitParseableFinishedMessage = [&Invocation, &FileSpecificDiagnostics](
-                                          int ExitStatus) {
+  auto emitParseableFinishedMessage = [&Invocation, &FileSpecificDiagnostics,
+                                       &OS](int ExitStatus) {
     const auto &IO = Invocation.getFrontendOptions().InputsAndOutputs;
     const auto OSPid = getpid();
     const auto ProcInfo = sys::TaskProcessInformation(OSPid);
@@ -2318,7 +2318,7 @@ int swift::performFrontend(ArrayRef<const char *> Args,
         std::copy(PrimaryDiags.begin(), PrimaryDiags.end(),
                   std::ostream_iterator<std::string>(JoinedDiags, Delim));
 
-        emitFinishedMessage(llvm::errs(),
+        emitFinishedMessage(OS,
                             mapFrontendInvocationToAction(Invocation),
                             JoinedDiags.str(), ExitStatus, Pid - idx, ProcInfo);
         return false;
@@ -2335,7 +2335,7 @@ int swift::performFrontend(ArrayRef<const char *> Args,
       std::ostringstream JoinedDiags;
       std::copy(AllDiagnostics.begin(), AllDiagnostics.end(),
                 std::ostream_iterator<std::string>(JoinedDiags, Delim));
-      emitFinishedMessage(llvm::errs(),
+      emitFinishedMessage(OS,
                           mapFrontendInvocationToAction(Invocation),
                           JoinedDiags.str(), ExitStatus, OSPid, ProcInfo);
     }