[Macros] Granular diagnostic when macro type is not found in a plugin

rdar://115571427

Author: rintaro

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

@@ -26,8 +26,13 @@ final class SwiftPluginServer {
     }
   }
 
+  struct LoadedLibraryPlugin {
+    var libraryPath: String
+    var handle: UnsafeMutableRawPointer
+  }
+
   /// Loaded dylib handles associated with the module name.
-  var loadedLibraryPlugins: [String: UnsafeMutableRawPointer] = [:]
+  var loadedLibraryPlugins: [String: LoadedLibraryPlugin] = [:]
 
   /// Resolved cached macros.
   var resolvedMacros: [MacroRef: Macro.Type] = [:]
@@ -50,33 +55,37 @@ extension SwiftPluginServer: PluginProvider {
     guard let dlHandle = PluginServer_load(libraryPath, &errorMessage) else {
       throw PluginServerError(message: String(cString: errorMessage!))
     }
-    loadedLibraryPlugins[moduleName] = dlHandle
+    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) -> Macro.Type? {
+  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 dlHandle = loadedLibraryPlugins[moduleName] else {
-      return nil
+    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, dlHandle, &errorMessage
+      moduleName, typeName, plugin.handle, &errorMessage
     ) else {
-      // FIXME: Propagate error message?
-      return nil
+      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 {
-      return nil
+      throw PluginServerError(message: "type '\(moduleName).\(typeName)' is not a valid macro implementation type in library plugin '\(plugin.libraryPath)'")
     }
 
     // Cache the resolved type.