[Macros] Initial implementation for synthesized member macro expansion.

Author: hborla

include/swift/AST/TypeCheckRequests.h

@@ -3856,6 +3856,23 @@ class ExpandMemberAttributeMacros
   bool isCached() const { return true; }
 };
 
+/// Expand synthesized member macros attached to the given declaration.
+class ExpandSynthesizedMemberMacroRequest
+    : public SimpleRequest<ExpandSynthesizedMemberMacroRequest,
+                           bool(Decl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, Decl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Resolve an external macro given its module and type name.
 class ExternalMacroDefinitionRequest
     : public SimpleRequest<ExternalMacroDefinitionRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -458,6 +458,9 @@ SWIFT_REQUEST(TypeChecker, ExpandMacroExpansionDeclRequest,
 SWIFT_REQUEST(TypeChecker, ExpandMemberAttributeMacros,
               bool(Decl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeCHecker, ExpandSynthesizedMemberMacroRequest,
+              bool(Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGenerator,
               Expr *(CustomAttr *, ValueDecl *),
               Cached, NoLocationInfo)

lib/AST/ASTVerifier.cpp

@@ -3654,12 +3654,13 @@ class Verifier : public ASTWalker {
     void checkSourceRanges(Decl *D) {
       PrettyStackTraceDecl debugStack("verifying ranges", D);
       const auto SR = D->getSourceRange();
+
+      // We don't care about source ranges on implicitly-generated
+      // decls.
+      if (D->isImplicit())
+        return;
+
       if (!SR.isValid()) {
-        // We don't care about source ranges on implicitly-generated
-        // decls.
-        if (D->isImplicit())
-          return;
-        
         Out << "invalid source range for decl: ";
         D->print(Out);
         Out << "\n";

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -344,6 +344,18 @@ func expandAttachedMacro(
         $0.withoutTrivia().description
       }.joined(separator: " ")
 
+    case let attachedMacro as MemberDeclarationMacro.Type:
+      let members = try attachedMacro.expansion(
+        of: customAttrNode,
+        attachedTo: declarationNode,
+        in: &context
+      )
+
+      // Form a buffer of member declarations to return to the caller.
+      evaluatedSyntaxStr = members.map {
+        $0.withoutTrivia().description
+      }.joined(separator: "\n\n")
+
     default:
       print("\(macroPtr) does not conform to any known attached macro protocol")
       return 1

lib/Sema/TypeCheckMacros.cpp

@@ -338,6 +338,31 @@ bool ExpandMemberAttributeMacros::evaluate(Evaluator &evaluator,
   return addedAttributes;
 }
 
+bool ExpandSynthesizedMemberMacroRequest::evaluate(Evaluator &evaluator,
+                                                   Decl *decl) const {
+  auto &ctx = decl->getASTContext();
+  auto *dc = decl->getInnermostDeclContext();
+  bool synthesizedMembers = false;
+
+  for (auto customAttrConst : decl->getSemanticAttrs().getAttributes<CustomAttr>()) {
+    auto customAttr = const_cast<CustomAttr *>(customAttrConst);
+    auto *macroDecl = evaluateOrDefault(
+        ctx.evaluator,
+        ResolveAttachedMacroRequest{customAttr, dc},
+        nullptr);
+
+    if (!macroDecl)
+      continue;
+
+    if (!macroDecl->getMacroRoles().contains(MacroRole::SynthesizedMembers))
+      continue;
+
+    // Expand the synthesized members.
+    synthesizedMembers |= expandSynthesizedMembers(customAttr, macroDecl, decl);
+  }
+
+  return synthesizedMembers;
+}
 
 /// Determine whether the given source file is from an expansion of the given
 /// macro.
@@ -1082,6 +1107,181 @@ bool swift::expandAttributes(CustomAttr *attr, MacroDecl *macro, Decl *member) {
   return addedAttributes;
 }
 
+bool swift::expandSynthesizedMembers(CustomAttr *attr, MacroDecl *macro,
+                                     Decl *decl) {
+  auto *dc = decl->getInnermostDeclContext();
+  ASTContext &ctx = dc->getASTContext();
+  SourceManager &sourceMgr = ctx.SourceMgr;
+  auto moduleDecl = dc->getParentModule();
+
+  auto attrSourceFile =
+    moduleDecl->getSourceFileContainingLocation(attr->AtLoc);
+  if (!attrSourceFile)
+    return false;
+
+  auto declSourceFile =
+      moduleDecl->getSourceFileContainingLocation(decl->getStartLoc());
+  if (!declSourceFile)
+    return false;
+
+  // Evaluate the macro.
+  NullTerminatedStringRef evaluatedSource;
+
+  if (isFromExpansionOfMacro(attrSourceFile, macro) ||
+      isFromExpansionOfMacro(declSourceFile, macro)) {
+    decl->diagnose(diag::macro_recursive, macro->getName());
+    return false;
+  }
+
+  auto macroDef = macro->getDefinition();
+  switch (macroDef.kind) {
+  case MacroDefinition::Kind::Undefined:
+  case MacroDefinition::Kind::Invalid:
+    // Already diagnosed as an error elsewhere.
+    return false;
+
+  case MacroDefinition::Kind::Builtin: {
+    switch (macroDef.getBuiltinKind()) {
+    case BuiltinMacroKind::ExternalMacro:
+      // FIXME: Error here.
+      return false;
+    }
+  }
+
+  case MacroDefinition::Kind::External: {
+    // Retrieve the external definition of the macro.
+    auto external = macroDef.getExternalMacro();
+    ExternalMacroDefinitionRequest request{
+        &ctx, external.moduleName, external.macroTypeName
+    };
+    auto externalDef = evaluateOrDefault(
+        ctx.evaluator, request, ExternalMacroDefinition()
+    );
+    if (!externalDef.opaqueHandle) {
+      decl->diagnose(diag::external_macro_not_found,
+                     external.moduleName.str(),
+                     external.macroTypeName.str(),
+                     macro->getName()
+      );
+      macro->diagnose(diag::decl_declared_here, macro->getName());
+      return false;
+    }
+
+    // Make sure macros are enabled before we expand.
+    if (!ctx.LangOpts.hasFeature(Feature::Macros)) {
+      decl->diagnose(diag::macro_experimental);
+      return false;
+    }
+
+#if SWIFT_SWIFT_PARSER
+    PrettyStackTraceDecl debugStack("expanding attribute macro", decl);
+
+    auto astGenAttrSourceFile = attrSourceFile->exportedSourceFile;
+    if (!astGenAttrSourceFile)
+      return false;
+
+    auto astGenDeclSourceFile = declSourceFile->exportedSourceFile;
+    if (!astGenDeclSourceFile)
+      return false;
+
+    const char *evaluatedSourceAddress;
+    ptrdiff_t evaluatedSourceLength;
+    swift_ASTGen_expandAttachedMacro(
+        &ctx.Diags,
+        externalDef.opaqueHandle,
+        astGenAttrSourceFile, attr->AtLoc.getOpaquePointerValue(),
+        astGenDeclSourceFile, decl->getStartLoc().getOpaquePointerValue(),
+        /*parentDeclSourceFile*/nullptr, /*parentDeclLoc*/nullptr,
+        &evaluatedSourceAddress, &evaluatedSourceLength);
+    if (!evaluatedSourceAddress)
+      return false;
+    evaluatedSource = NullTerminatedStringRef(evaluatedSourceAddress,
+                                              (size_t)evaluatedSourceLength);
+    break;
+#else
+    decl->diagnose(diag::macro_unsupported);
+    return false;
+#endif
+  }
+  }
+
+  // Figure out a reasonable name for the macro expansion buffer.
+  std::string bufferName;
+  {
+    llvm::raw_string_ostream out(bufferName);
+
+    out << "macro:"
+        << "@" << macro->getName().getBaseName();
+    if (auto bufferID = declSourceFile->getBufferID()) {
+      unsigned startLine, startColumn;
+      std::tie(startLine, startColumn) =
+          sourceMgr.getLineAndColumnInBuffer(decl->getStartLoc(), *bufferID);
+
+      SourceLoc endLoc =
+          Lexer::getLocForEndOfToken(sourceMgr, decl->getEndLoc());
+      unsigned endLine, endColumn;
+      std::tie(endLine, endColumn) =
+          sourceMgr.getLineAndColumnInBuffer(endLoc, *bufferID);
+
+      out << ":" << sourceMgr.getIdentifierForBuffer(*bufferID) << ":"
+          << startLine << ":" << startColumn
+          << "-" << endLine << ":" << endColumn;
+    }
+  }
+
+  // Dump macro expansions to standard output, if requested.
+  if (ctx.LangOpts.DumpMacroExpansions) {
+    llvm::errs() << bufferName
+                 << "\n------------------------------\n"
+                 << evaluatedSource
+                 << "\n------------------------------\n";
+  }
+
+  // Create a new source buffer with the contents of the expanded macro.
+  auto macroBuffer =
+      llvm::MemoryBuffer::getMemBufferCopy(evaluatedSource, bufferName);
+  unsigned macroBufferID = sourceMgr.addNewSourceBuffer(std::move(macroBuffer));
+  auto macroBufferRange = sourceMgr.getRangeForBuffer(macroBufferID);
+  GeneratedSourceInfo sourceInfo{
+      GeneratedSourceInfo::SynthesizedMemberMacroExpansion,
+      decl->getEndLoc(),
+      SourceRange(macroBufferRange.getStart(), macroBufferRange.getEnd()),
+      ASTNode(decl).getOpaqueValue(),
+      dc,
+      attr
+  };
+  sourceMgr.setGeneratedSourceInfo(macroBufferID, sourceInfo);
+  free((void*)evaluatedSource.data());
+
+  // Create a source file to hold the macro buffer. This is automatically
+  // registered with the enclosing module.
+  auto macroSourceFile = new (ctx) SourceFile(
+      *dc->getParentModule(), SourceFileKind::MacroExpansion, macroBufferID,
+      /*parsingOpts=*/{}, /*isPrimary=*/false);
+  macroSourceFile->setImports(declSourceFile->getImports());
+
+  PrettyStackTraceDecl debugStack(
+      "type checking expanded declaration macro", decl);
+
+  bool synthesizedMembers = false;
+  auto topLevelDecls = macroSourceFile->getTopLevelDecls();
+  for (auto member : topLevelDecls) {
+    member->setDeclContext(decl->getInnermostDeclContext());
+    member->setImplicit();
+
+    if (auto *nominal = dyn_cast<NominalTypeDecl>(decl)) {
+      nominal->addMember(member);
+    } else if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
+      extension->addMember(member);
+    }
+
+    TypeChecker::typeCheckDecl(member);
+    synthesizedMembers = true;
+  }
+
+  return synthesizedMembers;
+}
+
 MacroDecl *
 ResolveAttachedMacroRequest::evaluate(Evaluator &evaluator,
                                       CustomAttr *attr,

lib/Sema/TypeCheckMacros.h

@@ -53,6 +53,13 @@ void expandAccessors(
 /// on the custom attribute that references the given macro.
 bool expandAttributes(CustomAttr *attr, MacroDecl *macro, Decl *member);
 
+/// Expand the synthesized members for the given declaration based on
+/// the custom attribute that references the given macro.
+///
+/// Returns \c true if the macro added new synthesized members, \c false
+/// otherwise.
+bool expandSynthesizedMembers(CustomAttr *attr, MacroDecl *macro, Decl *decl);
+
 } // end namespace swift
 
 #endif /* SWIFT_SEMA_TYPECHECKMACROS_H */

lib/Sema/TypeCheckStorage.cpp

@@ -113,6 +113,13 @@ static void computeLoweredStoredProperties(NominalTypeDecl *decl,
   if (decl->hasTypeWrapper())
     (void)decl->getTypeWrapperProperty();
 
+  // Expand synthesized member macros.
+  // FIXME: Member macros can add members other than stored properties.
+  auto &ctx = decl->getASTContext();
+  evaluateOrDefault(ctx.evaluator,
+                    ExpandSynthesizedMemberMacroRequest{decl},
+                    false);
+
   // Just walk over the members of the type, forcing backing storage
   // for lazy properties and property wrappers to be synthesized.
   for (auto *member : implDecl->getMembers()) {

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -327,3 +327,20 @@ public struct AccessViaStorageMacro: AccessorDeclarationMacro {
     ]
   }
 }
+
+public struct TypeWrapperStorageMacro: MemberDeclarationMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo decl: DeclSyntax,
+    in context: inout MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    let storageVariable: VariableDeclSyntax =
+      """
+      private var _storage = _Storage()
+      """
+
+    return [
+      DeclSyntax(storageVariable),
+    ]
+  }
+}

test/Macros/composed_macro.swift

@@ -10,6 +10,7 @@
 // REQUIRES: OS=macosx
 
 @attached(memberAttributes) macro myTypeWrapper() = #externalMacro(module: "MacroDefinition", type: "TypeWrapperMacro")
+@attached(synthesizedMembers) macro typeWrapperStorage() = #externalMacro(module: "MacroDefinition", type: "TypeWrapperStorageMacro")
 @attached(accessor) macro accessViaStorage() = #externalMacro(module: "MacroDefinition", type: "AccessViaStorageMacro")
 
 struct _Storage {
@@ -21,10 +22,9 @@ struct _Storage {
   }
 }
 
+@typeWrapperStorage
 @myTypeWrapper
 struct S {
-  var _storage = _Storage()
-
   var x: Int
   var y: Int
 }