[Macros] Resolve in-process macros via external type name.

This approach works for both macros built into the compiler (e.g., the
builtin macros) as well as those that are loaded via plugin but don't
conform to the _CompilerPluginSupport protocol.

This eliminates all uses of the `MacroSystem` itself in ASTGen, and
pushes more of the implementation through ASTGen.

Author: DougGregor

include/swift/AST/CompilerPlugin.h

@@ -74,8 +74,8 @@ class CompilerPlugin {
     return reinterpret_cast<const Func *const *>(witnessTable)[(unsigned)entry];
   }
 
-public:
-  CompilerPlugin(const void *metadata, void *parentLibrary, ASTContext &ctx);
+  CompilerPlugin(
+      const void *metadata, void *parentLibrary, const void *witnessTable);
 
 private:
   /// Invoke the `_kind` method.
@@ -86,6 +86,9 @@ class CompilerPlugin {
   CompilerPlugin(const CompilerPlugin &) = delete;
   CompilerPlugin(CompilerPlugin &&) = default;
 
+  /// Try to resolve a compiler plugin given the metadata point.
+  static CompilerPlugin *fromMetatype(const void *metadata, ASTContext &ctx);
+
   /// Invoke the `_rewrite` method. The caller assumes ownership of the result
   /// string buffer and diagnostic buffers.
   Optional<NullTerminatedStringRef> invokeRewrite(

lib/AST/CompilerPlugin.cpp

@@ -57,24 +57,37 @@ using WitnessTableLookupFn = const void *(const void *type,
 extern "C" WitnessTableLookupFn swift_conformsToProtocol;
 #endif
 
-CompilerPlugin::CompilerPlugin(const void *metadata, void *parentLibrary,
-                               ASTContext &ctx)
-   : metadata(metadata), parentLibrary(parentLibrary)
+CompilerPlugin::CompilerPlugin(
+    const void *metadata, void *parentLibrary, const void *witnessTable)
+   : metadata(metadata), parentLibrary(parentLibrary),
+     witnessTable(witnessTable)
 {
+  assert(witnessTable && "Type does not conform to _CompilerPlugin");
+  kind = invokeKind();
+}
+
+CompilerPlugin::~CompilerPlugin() { }
+
+CompilerPlugin *CompilerPlugin::fromMetatype(
+    const void *metadata, ASTContext &ctx
+) {
 #if !SWIFT_SWIFT_PARSER
   auto *swift_conformsToProtocol = reinterpret_cast<WitnessTableLookupFn *>(
       ctx.getAddressOfSymbol("swift_conformsToProtocol"));
 #endif
   void *protocolDescriptor =
       ctx.getAddressOfSymbol(COMPILER_PLUGIN_PROTOCOL_DESCRIPTOR);
-  assert(swift_conformsToProtocol);
-  assert(protocolDescriptor);
-  witnessTable = swift_conformsToProtocol(metadata, protocolDescriptor);
-  assert(witnessTable && "Type does not conform to _CompilerPlugin");
-  kind = invokeKind();
-}
+  if ((&swift_conformsToProtocol == nullptr) || !protocolDescriptor)
+    return nullptr;
 
-CompilerPlugin::~CompilerPlugin() { }
+  auto witnessTable = swift_conformsToProtocol(metadata, protocolDescriptor);
+  if (!witnessTable)
+    return nullptr;
+
+  auto plugin = new CompilerPlugin(metadata, nullptr, witnessTable);
+  ctx.addCleanup([plugin] { delete plugin; });
+  return plugin;
+}
 
 namespace {
 // Corresponds to Swift type `(UnsafePointer<UInt8>, Int)`.

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -27,20 +27,20 @@ struct ExportedMacro {
   var macro: Macro.Type
 }
 
-/// Look up a macro with the given name.
+/// Resolve a reference to type metadata into a macro, if posible.
 ///
 /// Returns an unmanaged pointer to an ExportedMacro instance that describes
 /// the specified macro. If there is no macro with the given name, produces
 /// nil.
-@_cdecl("swift_ASTGen_lookupMacro")
-public func lookupMacro(
-  macroNamePtr: UnsafePointer<UInt8>
+@_cdecl("swift_ASTGen_resolveMacroType")
+public func resolveMacroType(
+  macroTypePtr: UnsafePointer<UInt8>
 ) -> UnsafeRawPointer? {
-  let macroSystem = MacroSystem.exampleSystem
+  let macroType = unsafeBitCast(macroTypePtr, to: Any.Type.self)
 
-  // Look for a macro with this name.
-  let macroName = String(cString: macroNamePtr)
-  guard let macro = macroSystem.lookup(macroName) else { return nil }
+  guard let macro = macroType as? Macro.Type else {
+    return nil
+  }
 
   // Allocate and initialize the exported macro.
   let exportedPtr = UnsafeMutablePointer<ExportedMacro>.allocate(capacity: 1)
@@ -158,3 +158,16 @@ func evaluateMacro(
     return 0
   }
 }
+
+// Makes sure that the type metadata for these macros can be found.
+public var allBuiltinMacros: [Any.Type] = [
+  ColorLiteralMacro.self,
+  ColumnMacro.self,
+  FileIDMacro.self,
+  FileLiteralMacro.self,
+  FilePathMacro.self,
+  FunctionMacro.self,
+  ImageLiteralMacro.self,
+  LineMacro.self,
+  StringifyMacro.self
+]

lib/Sema/TypeCheckMacros.cpp

@@ -35,7 +35,7 @@
 
 using namespace swift;
 
-extern "C" void *swift_ASTGen_lookupMacro(const char *macroName);
+extern "C" void *swift_ASTGen_resolveMacroType(const void *macroType);
 
 extern "C" void swift_ASTGen_destroyMacro(void *macro);
 
@@ -101,34 +101,30 @@ MacroDefinition MacroDefinitionRequest::evaluate(
 #if SWIFT_SWIFT_PARSER
   ASTContext &ctx = macro->getASTContext();
 
-  // FIXME: We need to perform lookups by resolving the external module name.
-
-  StringRef macroName = macro->getName().getBaseName().userFacingName();
-  // Look for a builtin macro with this name.
-  if (auto *builtinHandle = swift_ASTGen_lookupMacro(
-          macroName.str().c_str())) {
-    // Make sure we clean up after the macro.
-    ctx.addCleanup([builtinHandle]() {
-      swift_ASTGen_destroyMacro(builtinHandle);
-    });
-
-    return MacroDefinition::forBuiltin(
-        MacroDefinition::Expression, builtinHandle);
-  }
-
   /// Look for the type metadata given the external module and type names.
   auto macroMetatype = lookupMacroTypeMetadataByExternalName(
       ctx, macro->externalModuleName.str(),
       macro->externalMacroTypeName.str());
   if (macroMetatype) {
-    auto plugin = new CompilerPlugin(macroMetatype, nullptr, ctx);
-    ctx.addCleanup([plugin] { delete plugin; });
-    // FIXME: Handle other kinds of macros.
-    return MacroDefinition::forCompilerPlugin(
-        MacroDefinition::Expression, plugin);
-  }
+    // Check whether the macro metatype can be handled as a compiler plugin.
+    // We look here first, because compiler plugins are meant to be resilient.
+    if (auto plugin = CompilerPlugin::fromMetatype(macroMetatype, ctx)) {
+      // FIXME: Handle other kinds of macros.
+      return MacroDefinition::forCompilerPlugin(
+          MacroDefinition::Expression, plugin);
+    }
 
+    // Otherwise, check whether the macro metatype can be handled as a builtin.
+    if (auto builtin = swift_ASTGen_resolveMacroType(macroMetatype)) {
+      // Make sure we clean up after the macro.
+      ctx.addCleanup([builtin]() {
+        swift_ASTGen_destroyMacro(builtin);
+      });
 
+      return MacroDefinition::forBuiltin(
+          MacroDefinition::Expression, builtin);
+    }
+  }
 #endif
 
   ctx.Diags.diagnose(
@@ -206,7 +202,7 @@ Expr *swift::expandMacroExpr(
          /*range*/ Lexer::getCharSourceRangeFromSourceRange(
              sourceMgr, expr->getSourceRange()), ctx, pluginDiags);
       for (auto &diag : pluginDiags) {
-\        auto loc = sourceMgr.getLocForOffset(*bufferID, diag.position);
+        auto loc = sourceMgr.getLocForOffset(*bufferID, diag.position);
         Diag<DeclName, StringRef> diagID;
         switch (diag.severity) {
         case CompilerPlugin::DiagnosticSeverity::Note:

test/Macros/builtin_macros.swift

@@ -1,9 +1,9 @@
 // RUN: %target-swift-frontend -enable-experimental-feature Macros -enable-experimental-feature BuiltinMacros -dump-ast %s -module-name MacrosTest 2>&1 | %FileCheck %s
 // REQUIRES: OS=macosx
 
-macro function<T: ExpressibleByStringLiteral>: T = BuiltinMacros.FunctionMacro
-macro line<T: ExpressibleByIntegerLiteral>: T = BuiltinMacros.LineMacro
-macro column<T: ExpressibleByIntegerLiteral>: T = BuiltinMacros.ColumnMacro
+macro function<T: ExpressibleByStringLiteral>: T = _SwiftSyntaxMacros.FunctionMacro
+macro line<T: ExpressibleByIntegerLiteral>: T = _SwiftSyntaxMacros.LineMacro
+macro column<T: ExpressibleByIntegerLiteral>: T = _SwiftSyntaxMacros.ColumnMacro
 
 // CHECK: macro_expansion_expr implicit type='String'
 // CHECK-NEXT: string_literal_expr{{.*}}Macro expansion of #function in{{.*}}value="MacrosTest"

test/Macros/macros.swift

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend -enable-experimental-feature Macros -dump-ast %s -module-name MacrosTest 2>&1 | %FileCheck %s
 // REQUIRES: OS=macosx
 
-macro stringify<T>(_ value: T) -> (T, String) = BuiltinMacros.StringifyMacro
+macro stringify<T>(_ value: T) -> (T, String) = _SwiftSyntaxMacros.StringifyMacro
 
 func test(a: Int, b: Int) {
   let s = #stringify(a + b)