[Macros] Use 'LibraryPluginProvider' in swift-plugin-server

Move 'PluginProvider' logic to 'SwiftCompilerPluginMessageHandling'
module so the compiler can reuse that logic for the actual in-process
plugins.

Author: rintaro

test/Macros/macro_plugin_server.swift

@@ -87,7 +87,7 @@ func testStringify(a: Int, b: Int) {
   let s3: String = #stringify(b + a).1
   print(s3)
 
-  // expected-error @+1 {{macro implementation type 'MacroDefinition.TypeDoesNotExist' could not be found in library plugin '}}
+  // expected-error @+1 {{type 'MacroDefinition.TypeDoesNotExist' could not be found in library plugin '}}
   _ = #missing()
 
   // expected-error @+1 {{type 'MacroDefinition.NotMacroStruct' is not a valid macro implementation type in library plugin '}}

tools/swift-plugin-server/CMakeLists.txt

@@ -4,17 +4,13 @@ if (SWIFT_BUILD_SWIFT_SYNTAX)
   add_swift_host_library(_swiftCSwiftPluginServer OBJECT
     Sources/CSwiftPluginServer/PluginServer.cpp
   )
-  target_link_libraries(_swiftCSwiftPluginServer PRIVATE
-    swiftDemangling
-  )
   target_include_directories(_swiftCSwiftPluginServer PUBLIC
     Sources/CSwiftPluginServer/include
   )
 
   add_pure_swift_host_tool(swift-plugin-server
     Sources/swift-plugin-server/swift-plugin-server.swift
     DEPENDENCIES
-      swiftDemangling
       $<TARGET_OBJECTS:_swiftCSwiftPluginServer>
     SWIFT_COMPONENT
       compiler

tools/swift-plugin-server/Sources/CSwiftPluginServer/PluginServer.cpp

@@ -11,11 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "PluginServer.h"
-#include "swift/ABI/MetadataValues.h"
-#include "swift/Demangling/Demangle.h"
-#include "llvm/Support/DynamicLibrary.h"
 
 #if defined(_WIN32)
+#include <stdio.h>
 #include <io.h>
 #elif defined(__unix__) || defined(__APPLE__)
 #include <dlfcn.h>
@@ -25,8 +23,6 @@
 #include <errno.h>
 #include <string.h>
 
-using namespace swift;
-
 namespace {
 struct ConnectionHandle {
   int inputFD;
@@ -136,51 +132,3 @@ ptrdiff_t PluginServer_write(const void *server, const void *data,
   return ::write(connection->outputFD, data, nbyte);
 #endif
 }
-
-void *PluginServer_load(const char *plugin, const char **errorMessage) {
-  // Use a static allocation for the error as the client will not release the
-  // string.  POSIX 2008 (IEEE-1003.1-2008) specifies that it is implementation
-  // defined if `dlerror` is re-entrant.  Take advantage of that and make it
-  // thread-unsafe.  This ensures that the string outlives the call permitting
-  // the client to duplicate it.
-  static std::string error;
-  auto library = llvm::sys::DynamicLibrary::getLibrary(plugin, &error);
-  if (library.isValid())
-    return library.getOSSpecificHandle();
-  *errorMessage = error.c_str();
-  return nullptr;
-}
-
-const void *PluginServer_lookupMacroTypeMetadataByExternalName(
-    const char *moduleName, const char *typeName, void *libraryHint,
-    const char **errorMessage) {
-  // Look up the type metadata accessor as a struct, enum, or class.
-  const Demangle::Node::Kind typeKinds[] = {
-      Demangle::Node::Kind::Structure,
-      Demangle::Node::Kind::Enum,
-      Demangle::Node::Kind::Class,
-  };
-
-  void *accessorAddr = nullptr;
-  for (auto typeKind : typeKinds) {
-    auto symbolName =
-        mangledNameForTypeMetadataAccessor(moduleName, typeName, typeKind);
-
-#if !defined(_WIN32)
-    if (libraryHint == nullptr)
-      libraryHint = RTLD_DEFAULT;
-#endif
-    accessorAddr = llvm::sys::DynamicLibrary{libraryHint}
-                      .getAddressOfSymbol(symbolName.c_str());
-    if (accessorAddr)
-      break;
-  }
-
-  if (!accessorAddr)
-    return nullptr;
-
-  // Call the accessor to form type metadata.
-  using MetadataAccessFunc = const void *(MetadataRequest);
-  auto accessor = reinterpret_cast<MetadataAccessFunc*>(accessorAddr);
-  return accessor(MetadataRequest(MetadataState::Complete));
-}

tools/swift-plugin-server/Sources/CSwiftPluginServer/include/PluginServer.h

@@ -37,19 +37,6 @@ ptrdiff_t PluginServer_read(const void *connHandle, void *data, size_t nbyte);
 ptrdiff_t PluginServer_write(const void *connHandle, const void *data,
                              size_t nbyte);
 
-//===----------------------------------------------------------------------===//
-// Dynamic link
-//===----------------------------------------------------------------------===//
-
-/// Load a dynamic link library, and return the handle.
-void *PluginServer_load(const char *filename, const char **errorMessage);
-
-/// Resolve a type metadata by a pair of the module name and the type name.
-/// 'libraryHint' is a
-const void *PluginServer_lookupMacroTypeMetadataByExternalName(
-    const char *moduleName, const char *typeName, void *libraryHint,
-    const char **errorMessage);
-
 #ifdef __cplusplus
 }
 #endif

tools/swift-plugin-server/Sources/swift-plugin-server/swift-plugin-server.swift

@@ -10,95 +10,23 @@
 //
 //===----------------------------------------------------------------------===//
 
-import SwiftCompilerPluginMessageHandling
-import SwiftSyntaxMacros
+@_spi(Compiler) import SwiftCompilerPluginMessageHandling
 import swiftLLVMJSON
 import CSwiftPluginServer
 
 @main
 final class SwiftPluginServer {
-  struct MacroRef: Hashable {
-    var moduleName: String
-    var typeName: String
-    init(_ moduleName: String, _ typeName: String) {
-      self.moduleName = moduleName
-      self.typeName = typeName
-    }
-  }
-
-  struct LoadedLibraryPlugin {
-    var libraryPath: String
-    var handle: UnsafeMutableRawPointer
-  }
-
-  /// Loaded dylib handles associated with the module name.
-  var loadedLibraryPlugins: [String: LoadedLibraryPlugin] = [:]
-
-  /// Resolved cached macros.
-  var resolvedMacros: [MacroRef: Macro.Type] = [:]
-
   /// @main entry point.
   static func main() throws {
     let connection = try PluginHostConnection()
     let messageHandler = CompilerPluginMessageHandler(
       connection: connection,
-      provider: self.init()
+      provider: LibraryPluginProvider.shared
     )
     try messageHandler.main()
   }
 }
 
-extension SwiftPluginServer: PluginProvider {
-  /// Load a macro implementation from the dynamic link library.
-  func loadPluginLibrary(libraryPath: String, moduleName: String) throws {
-    var errorMessage: UnsafePointer<CChar>?
-    guard let dlHandle = PluginServer_load(libraryPath, &errorMessage) else {
-      throw PluginServerError(message: "loader error: " + String(cString: errorMessage!))
-    }
-    loadedLibraryPlugins[moduleName] = LoadedLibraryPlugin(
-      libraryPath: libraryPath,
-      handle: dlHandle
-    )
-  }
-
-  /// Lookup a loaded macro by a pair of module name and type name.
-  func resolveMacro(moduleName: String, typeName: String) throws -> Macro.Type {
-    if let resolved = resolvedMacros[.init(moduleName, typeName)] {
-      return resolved
-    }
-
-    // Find 'dlopen'ed library for the module name.
-    guard let plugin = loadedLibraryPlugins[moduleName] else {
-      // NOTE: This should be unreachable. Compiler should not use this server
-      // unless the plugin loading succeeded.
-      throw PluginServerError(message: "(plugin-server) plugin not loaded for module '\(moduleName)'")
-    }
-
-    // Lookup the type metadata.
-    var errorMessage: UnsafePointer<CChar>?
-    guard let macroTypePtr = PluginServer_lookupMacroTypeMetadataByExternalName(
-      moduleName, typeName, plugin.handle, &errorMessage
-    ) else {
-      throw PluginServerError(message: "macro implementation type '\(moduleName).\(typeName)' could not be found in library plugin '\(plugin.libraryPath)'")
-    }
-
-    // THe type must be a 'Macro' type.
-    let macroType = unsafeBitCast(macroTypePtr, to: Any.Type.self)
-    guard let macro = macroType as? Macro.Type else {
-      throw PluginServerError(message: "type '\(moduleName).\(typeName)' is not a valid macro implementation type in library plugin '\(plugin.libraryPath)'")
-    }
-
-    // Cache the resolved type.
-    resolvedMacros[.init(moduleName, typeName)] = macro
-    return macro
-  }
-
-  /// This 'PluginProvider' implements 'loadLibraryMacro()'.
-  var features: [SwiftCompilerPluginMessageHandling.PluginFeature] {
-    [.loadPluginLibrary]
-  }
-}
-
 final class PluginHostConnection: MessageConnection {
   let handle: UnsafeRawPointer
   init() throws {