[Macros] Plumb the owning module and supplemental modules through to Macro.

Plumb the information about the owning module and supplemental
signature modules through to the Macro data structure, for both
built-in and plugin macros.

We're resolving the given module names into module declarations, but
otherwise performing no checking and not emitting any diagnostics.
This information is not yet used.

Author: DougGregor

include/swift/AST/CompilerPlugin.h

@@ -52,6 +52,11 @@ class CompilerPlugin {
     GenericSignature = 4,
     // static func _typeSignature(...) -> (UnsafePointer<UInt8>, count: Int)
     TypeSignature = 5,
+    // static func _owningModule(...) -> (UnsafePointer<UInt8>, count: Int)
+    OwningModule = 6,
+    // static func _supplementalSignatureModules(...)
+    //     -> (UnsafePointer<UInt8>, count: Int)
+    SupplementalSignatureModules = 7,
   };
 
   /// The plugin type metadata.
@@ -100,6 +105,14 @@ class CompilerPlugin {
   /// result string buffer.
   StringRef invokeTypeSignature() const;
 
+  /// Invoke the `_owningModule` method. The caller assumes ownership of the
+  /// result string buffer.
+  StringRef invokeOwningModule() const;
+
+  /// Invoke the `_supplementalSignatureModules` method. The caller assumes
+  /// ownership of the result string buffer.
+  StringRef invokeSupplementalSignatureModules() const;
+
   StringRef getName() const {
     return name;
   }

lib/AST/CompilerPlugin.cpp

@@ -319,3 +319,27 @@ StringRef CompilerPlugin::invokeTypeSignature() const {
   llvm_unreachable("Incompatible host compiler");
 #endif
 }
+
+StringRef CompilerPlugin::invokeOwningModule() const {
+#if __clang__
+  using Method = SWIFT_CC CharBuffer(
+      SWIFT_CONTEXT const void *, const void *, const void *);
+  auto method = getWitnessMethodUnsafe<Method>(
+      WitnessTableEntry::OwningModule);
+  return method(metadata, metadata, witnessTable).str();
+#else
+  llvm_unreachable("Incompatible host compiler");
+#endif
+}
+
+StringRef CompilerPlugin::invokeSupplementalSignatureModules() const {
+#if __clang__
+  using Method = SWIFT_CC CharBuffer(
+      SWIFT_CONTEXT const void *, const void *, const void *);
+  auto method = getWitnessMethodUnsafe<Method>(
+      WitnessTableEntry::SupplementalSignatureModules);
+  return method(metadata, metadata, witnessTable).str();
+#else
+  llvm_unreachable("Incompatible host compiler");
+#endif
+}

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -112,6 +112,48 @@ public func getMacroTypeSignature(
   }
 }
 
+/// Query the documentation of the given macro.
+@_cdecl("swift_ASTGen_getMacroDocumentation")
+public func getMacroDocumentation(
+  macroPtr: UnsafeMutablePointer<UInt8>,
+  documentationPtr: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
+  documentationLengthPtr: UnsafeMutablePointer<Int>
+) {
+  macroPtr.withMemoryRebound(to: ExportedMacro.self, capacity: 1) { macro in
+    (documentationPtr.pointee, documentationLengthPtr.pointee) =
+        allocateUTF8String(macro.pointee.macro.documentation)
+  }
+}
+
+/// Query the owning module of the given macro.
+@_cdecl("swift_ASTGen_getMacroOwningModule")
+public func getMacroOwningModule(
+  macroPtr: UnsafeMutablePointer<UInt8>,
+  owningModulePtr: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
+  owningModuleLengthPtr: UnsafeMutablePointer<Int>
+) {
+  macroPtr.withMemoryRebound(to: ExportedMacro.self, capacity: 1) { macro in
+    (owningModulePtr.pointee, owningModuleLengthPtr.pointee) =
+        allocateUTF8String(macro.pointee.macro.owningModule)
+  }
+}
+
+/// Query the supplemental signature modules of the given macro,
+/// as a semicolon-separated string
+@_cdecl("swift_ASTGen_getMacroSupplementalSignatureModules")
+public func getMacroSupplementableSignatureModules(
+  macroPtr: UnsafeMutablePointer<UInt8>,
+  modulesPtr: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
+  modulesLengthPtr: UnsafeMutablePointer<Int>
+) {
+  macroPtr.withMemoryRebound(to: ExportedMacro.self, capacity: 1) { macro in
+    let modules = macro.pointee.macro.supplementalSignatureModules
+        .joined(separator: ";")
+    (modulesPtr.pointee, modulesLengthPtr.pointee) =
+        allocateUTF8String(modules)
+  }
+}
+
 /// Query the macro evaluation context given the evaluation
 /// context sources.
 @_cdecl("swift_ASTGen_getMacroEvaluationContext")

lib/CompilerPluginSupport/CompilerPluginSupport.swift

@@ -69,4 +69,20 @@ public protocol _CompilerPlugin {
   /// - Returns: A newly allocated buffer containing the type signature. The
   ///   caller is responsible for managing the memory.
   static func _typeSignature() -> (UnsafePointer<UInt8>, count: Int)
+
+
+  /// Returns the module that owns this macro.
+  ///
+  /// - Returns: A newly allocated buffer containing the owning module name. The
+  ///   caller is responsible for managing the memory.
+  static func _owningModule() -> (UnsafePointer<UInt8>, count: Int)
+
+  /// Returns the set of modules that are needed (beyond the owning module) to
+  /// process the module signature.
+  ///
+  /// - Returns: A newly allocated buffer containing a string with all of the
+  /// supplemental signature module names, separated by semicolons. The caller
+  /// is responsible for managing the memory.
+  static func _supplementalSignatureModules()
+      -> (UnsafePointer<UInt8>, count: Int)
 }

lib/Sema/TypeCheckMacros.cpp

@@ -54,6 +54,15 @@ swift_ASTGen_getMacroTypeSignature(void *macro,
                                    const char **signaturePtr,
                                    ptrdiff_t *signatureLengthPtr);
 
+extern "C" void
+swift_ASTGen_getMacroOwningModule(void *macro,
+                                  const char **owningModuleNamePtr,
+                                  ptrdiff_t *owningModuleNameLengthPtr);
+
+extern "C" void
+swift_ASTGen_getMacroSupplementalSignatureModules(
+    void *macro, const char **moduleNamesPtr, ptrdiff_t *moduleNamesLengthPtr);
+
 /// Create a new macro signature context buffer describing the macro signature.
 ///
 /// The macro signature is a user-defined generic signature and return
@@ -138,13 +147,39 @@ getMacroSignature(
       typealias->getGenericSignature(), typealias->getUnderlyingType());
 }
 
+
+
 /// Create a macro.
 static Macro *createMacro(
     ModuleDecl *mod, Identifier macroName,
     Macro::ImplementationKind implKind,
     Optional<StringRef> genericSignature, StringRef typeSignature,
+    StringRef owningModuleName,
+    ArrayRef<StringRef> supplementalImportModuleNames,
     void* opaqueHandle
 ) {
+  ASTContext &ctx = mod->getASTContext();
+
+  // Look up the owning module.
+  ModuleDecl *owningModule = ctx.getLoadedModule(
+      ctx.getIdentifier(owningModuleName));
+  if (!owningModule) {
+    // FIXME: diagnostic here
+    return nullptr;
+  }
+  // FIXME: Check that mod imports owningModule
+
+  // Look up all of the supplemental import modules.
+  SmallVector<ModuleDecl *, 1> supplementalImportModules;
+  for (auto supplementalModuleName : supplementalImportModuleNames) {
+    auto supplementalModuleId = ctx.getIdentifier(supplementalModuleName);
+    if (auto supplementalModule = ctx.getLoadedModule(supplementalModuleId)) {
+      supplementalImportModules.push_back(supplementalModule);
+
+      // FIXME: Check that mod imports supplementalModule somewhere.
+    }
+  }
+
   // Get the type signature of the macro.
   auto signature = getMacroSignature(
       mod, macroName, genericSignature, typeSignature);
@@ -154,18 +189,17 @@ static Macro *createMacro(
   }
 
   // FIXME: All macros are expression macros right now
-  ASTContext &ctx = mod->getASTContext();
   return new (ctx) Macro(
       Macro::Expression, implKind, macroName,
       signature->first, signature->second,
-      /*FIXME:owningModule*/mod, /*FIXME:supplementalImportModules*/{},
+      owningModule, supplementalImportModules,
       opaqueHandle);
 }
 
 /// Create a builtin macro.
 static Macro *createBuiltinMacro(
     ModuleDecl *mod, Identifier macroName, void *opaqueHandle) {
-  // Form the macro generic signature.
+  // Get the macro generic signature.
   const char *genericSignaturePtr;
   ptrdiff_t genericSignatureLength;
   swift_ASTGen_getMacroGenericSignature(opaqueHandle, &genericSignaturePtr,
@@ -178,7 +212,7 @@ static Macro *createBuiltinMacro(
   if (genericSignaturePtr && genericSignatureLength)
     genericSignature = StringRef(genericSignaturePtr, genericSignatureLength);
 
-  // Form the macro type signature.
+  // Get the macro type signature.
   const char *typeSignaturePtr;
   ptrdiff_t typeSignatureLength;
   swift_ASTGen_getMacroTypeSignature(opaqueHandle, &typeSignaturePtr,
@@ -188,9 +222,34 @@ static Macro *createBuiltinMacro(
   };
   StringRef typeSignature = StringRef(typeSignaturePtr, typeSignatureLength);
 
+  // Get the owning module name.
+  const char *owningModuleNamePtr;
+  ptrdiff_t owningModuleNameLength;
+  swift_ASTGen_getMacroOwningModule(opaqueHandle, &owningModuleNamePtr,
+                                    &owningModuleNameLength);
+  SWIFT_DEFER {
+    free((void*)owningModuleNamePtr);
+  };
+  StringRef owningModuleName = StringRef(
+      owningModuleNamePtr, owningModuleNameLength);
+
+  // Get the supplemental signature module names.
+  const char *supplementalModuleNamesPtr;
+  ptrdiff_t supplementalModuleNamesLength;
+  swift_ASTGen_getMacroSupplementalSignatureModules(
+      opaqueHandle, &supplementalModuleNamesPtr,
+      &supplementalModuleNamesLength);
+  SWIFT_DEFER {
+    free((void*)supplementalModuleNamesPtr);
+  };
+  SmallVector<StringRef, 2> supplementalModuleNames;
+  StringRef(owningModuleNamePtr, owningModuleNameLength)
+    .split(supplementalModuleNames, ";", -1, false);
+
   return createMacro(
       mod, macroName, Macro::ImplementationKind::Builtin,
       genericSignature, typeSignature,
+      owningModuleName, supplementalModuleNames,
       opaqueHandle);
 }
 
@@ -208,9 +267,24 @@ static Macro *createPluginMacro(
     free((void*)typeSignature.data());
   };
 
+  auto owningModuleName = plugin->invokeOwningModule();
+  SWIFT_DEFER {
+    free((void*)owningModuleName.data());
+  };
+
+  // Get the supplemental signature module names.
+  auto supplementalModuleNamesStr =
+      plugin->invokeSupplementalSignatureModules();
+  SWIFT_DEFER {
+    free((void*)supplementalModuleNamesStr.data());
+  };
+  SmallVector<StringRef, 2> supplementalModuleNames;
+  supplementalModuleNamesStr
+    .split(supplementalModuleNames, ";", -1, false);
+
   return createMacro(
       mod, macroName, Macro::ImplementationKind::Plugin, genSignature,
-      typeSignature, plugin);
+      typeSignature, owningModuleName, supplementalModuleNames, plugin);
 }
 
 ArrayRef<Macro *> MacroLookupRequest::evaluate(

test/Macros/Inputs/macro_definition.swift

@@ -28,6 +28,24 @@ struct StringifyMacro: _CompilerPlugin {
     }
   }
 
+  static func _owningModule() -> (UnsafePointer<UInt8>, count: Int) {
+    var swiftModule = "Swift"
+    return swiftModule.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _supplementalSignatureModules() -> (UnsafePointer<UInt8>, count: Int) {
+    var nothing = ""
+    return nothing.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
   static func _kind() -> _CompilerPluginKind {
     .expressionMacro
   }

test/Macros/Inputs/macro_definition_missing_allmacros.swift

@@ -29,6 +29,24 @@ struct DummyMacro: _CompilerPlugin {
     }
   }
 
+  static func _owningModule() -> (UnsafePointer<UInt8>, count: Int) {
+    var swiftModule = "Swift"
+    return swiftModule.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
+  static func _supplementalSignatureModules() -> (UnsafePointer<UInt8>, count: Int) {
+    var nothing = ""
+    return nothing.withUTF8 { buffer in
+      let result = UnsafeMutablePointer<UInt8>.allocate(capacity: buffer.count)
+      result.initialize(from: buffer.baseAddress!, count: buffer.count)
+      return (UnsafePointer(result), count: buffer.count)
+    }
+  }
+
   static func _kind() -> _CompilerPluginKind {
     .expressionMacro
   }