Merge pull request #63418 from DougGregor/mangle-attached-macros

Author: DougGregor

docs/ABI/Mangling.rst

@@ -396,7 +396,10 @@ Entities
 
   macro-discriminator-list ::= macro-discriminator-list? 'fM' macro-expansion-operator INDEX
 
+  macro-expansion-operator ::= identifier 'a' // accessor attached macro
+  macro-expansion-operator ::= identifier 'A' // member-attribute attached macro
   macro-expansion-operator ::= identifier 'f' // freestanding macro
+  macro-expansion-operator ::= identifier 'm' // member attached macro
   macro-expansion-operator ::= identifier 'u' // uniquely-named entity
 
   file-discriminator ::= identifier 'Ll'     // anonymous file-discriminated declaration

include/swift/AST/ASTMangler.h

@@ -343,6 +343,7 @@ class ASTMangler : public Mangler {
 
   std::string mangleTypeAsContextUSR(const NominalTypeDecl *type);
 
+  void appendAnyDecl(const ValueDecl *Decl);
   std::string mangleAnyDecl(const ValueDecl *Decl, bool prefix,
                             bool respectOriginallyDefinedIn = false);
   std::string mangleDeclAsUSR(const ValueDecl *Decl, StringRef USRPrefix);
@@ -368,9 +369,12 @@ class ASTMangler : public Mangler {
 
   std::string mangleMacroExpansion(const MacroExpansionExpr *expansion);
   std::string mangleMacroExpansion(const MacroExpansionDecl *expansion);
+  std::string mangleAttachedMacroExpansion(
+      const Decl *decl, CustomAttr *attr, MacroRole role);
+
   void appendMacroExpansionContext(SourceLoc loc, DeclContext *origDC);
   void appendMacroExpansionOperator(
-      StringRef macroName, unsigned discriminator);
+      StringRef macroName, MacroRole role, unsigned discriminator);
 
   enum SpecialContext {
     ObjCContext,

include/swift/AST/Decl.h

@@ -875,6 +875,11 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// declaration.
   void forEachAttachedMacro(MacroRole role, MacroCallback) const;
 
+  /// Retrieve the discriminator for the given custom attribute that names
+  /// an attached macro.
+  unsigned getAttachedMacroDiscriminator(
+      MacroRole role, const CustomAttr *attr) const;
+
   /// Returns the innermost enclosing decl with an availability annotation.
   const Decl *getInnermostDeclWithAvailability() const;
 

include/swift/Demangling/DemangleNodes.def

@@ -32,6 +32,7 @@ NODE(AssociatedType)
 NODE(AssociatedTypeRef)
 NODE(AssociatedTypeMetadataAccessor)
 NODE(DefaultAssociatedTypeMetadataAccessor)
+NODE(AccessorAttachedMacroExpansion)
 NODE(AssociatedTypeWitnessTableAccessor)
 NODE(BaseWitnessTableAccessor)
 NODE(AutoClosureType)
@@ -151,6 +152,8 @@ NODE(LocalDeclName)
 NODE(Macro)
 NODE(MacroExpansionUniqueName)
 CONTEXT_NODE(MaterializeForSet)
+NODE(MemberAttachedMacroExpansion)
+NODE(MemberAttributeAttachedMacroExpansion)
 NODE(MergedFunction)
 NODE(Metatype)
 NODE(MetatypeRepresentation)

lib/AST/ASTMangler.cpp

@@ -33,6 +33,7 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/SILLayout.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/ClangImporter/ClangImporter.h"
@@ -785,19 +786,7 @@ std::string ASTMangler::mangleTypeAsUSR(Type Ty) {
   return finalize();
 }
 
-std::string
-ASTMangler::mangleAnyDecl(const ValueDecl *Decl,
-                          bool prefix,
-                          bool respectOriginallyDefinedIn) {
-  DWARFMangling = true;
-  RespectOriginallyDefinedIn = respectOriginallyDefinedIn;
-  if (prefix) {
-    beginMangling();
-  } else {
-    beginManglingWithoutPrefix();
-  }
-  llvm::SaveAndRestore<bool> allowUnnamedRAII(AllowNamelessEntities, true);
-
+void ASTMangler::appendAnyDecl(const ValueDecl *Decl) {
   if (auto Ctor = dyn_cast<ConstructorDecl>(Decl)) {
     appendConstructorEntity(Ctor, /*isAllocating=*/false);
   } else if (auto Dtor = dyn_cast<DestructorDecl>(Decl)) {
@@ -811,6 +800,22 @@ ASTMangler::mangleAnyDecl(const ValueDecl *Decl,
   } else {
     appendEntity(Decl);
   }
+}
+
+std::string
+ASTMangler::mangleAnyDecl(const ValueDecl *Decl,
+                          bool prefix,
+                          bool respectOriginallyDefinedIn) {
+  DWARFMangling = true;
+  RespectOriginallyDefinedIn = respectOriginallyDefinedIn;
+  if (prefix) {
+    beginMangling();
+  } else {
+    beginManglingWithoutPrefix();
+  }
+  llvm::SaveAndRestore<bool> allowUnnamedRAII(AllowNamelessEntities, true);
+
+  appendAnyDecl(Decl);
 
   // We have a custom prefix, so finalize() won't verify for us. If we're not
   // in invalid code (coming from an IDE caller) verify manually.
@@ -3382,6 +3387,7 @@ void ASTMangler::appendEntity(const ValueDecl *decl) {
         expansion->getLoc(), expansion->getDeclContext());
     appendMacroExpansionOperator(
         expansion->getMacro().getBaseName().userFacingName(),
+        MacroRole::Declaration,
         expansion->getDiscriminator());
     return;
   }
@@ -3729,6 +3735,7 @@ void ASTMangler::appendMacroExpansionContext(
   DeclContext *outerExpansionDC;
   DeclBaseName baseName;
   unsigned discriminator;
+  MacroRole role;
   switch (generatedSourceInfo->kind) {
   case GeneratedSourceInfo::ExpressionMacroExpansion: {
     auto parent = ASTNode::getFromOpaqueValue(generatedSourceInfo->astNode);
@@ -3737,11 +3744,13 @@ void ASTMangler::appendMacroExpansionContext(
       outerExpansionLoc = expr->getLoc();
       baseName = expr->getMacroName().getBaseName();
       discriminator = expr->getDiscriminator();
+      role = MacroRole::Expression;
     } else {
       auto decl = cast<MacroExpansionDecl>(parent.get<Decl *>());
       outerExpansionLoc = decl->getLoc();
       baseName = decl->getMacro().getBaseName();
       discriminator = decl->getDiscriminator();
+      role = MacroRole::Declaration;
     }
     break;
   }
@@ -3754,12 +3763,40 @@ void ASTMangler::appendMacroExpansionContext(
     outerExpansionLoc = expansion->getLoc();
     outerExpansionDC = expansion->getDeclContext();
     discriminator = expansion->getDiscriminator();
+    role = MacroRole::Declaration;
     break;
   }
 
   case GeneratedSourceInfo::AccessorMacroExpansion:
   case GeneratedSourceInfo::MemberAttributeMacroExpansion:
-  case GeneratedSourceInfo::MemberMacroExpansion:
+  case GeneratedSourceInfo::MemberMacroExpansion: {
+    auto decl = ASTNode::getFromOpaqueValue(generatedSourceInfo->astNode)
+      .get<Decl *>();
+    auto attr = generatedSourceInfo->attachedMacroCustomAttr;
+
+    switch (generatedSourceInfo->kind) {
+    case GeneratedSourceInfo::AccessorMacroExpansion:
+      role = MacroRole::Accessor;
+      break;
+
+    case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+      role = MacroRole::MemberAttribute;
+      break;
+
+    case GeneratedSourceInfo::MemberMacroExpansion:
+      role = MacroRole::Member;
+      break;
+
+    default:
+      llvm_unreachable("Unhandled macro role");
+    }
+
+    outerExpansionLoc = decl->getLoc();
+    outerExpansionDC = decl->getDeclContext();
+    discriminator = decl->getAttachedMacroDiscriminator(role, attr);
+    break;
+  }
+
   case GeneratedSourceInfo::PrettyPrinted:
   case GeneratedSourceInfo::ReplacedFunctionBody:
     return appendContext(origDC, StringRef());
@@ -3772,14 +3809,33 @@ void ASTMangler::appendMacroExpansionContext(
 
   // Append our own context and discriminator.
   appendMacroExpansionContext(outerExpansionLoc, origDC);
-  appendMacroExpansionOperator(baseName.userFacingName(), discriminator);
+  appendMacroExpansionOperator(
+      baseName.userFacingName(), role, discriminator);
 }
 
 void ASTMangler::appendMacroExpansionOperator(
-    StringRef macroName, unsigned discriminator
+    StringRef macroName, MacroRole role, unsigned discriminator
 ) {
   appendIdentifier(macroName);
-  appendOperator("fMf", Index(discriminator));
+
+  switch (role) {
+  case MacroRole::Expression:
+  case MacroRole::Declaration:
+    appendOperator("fMf", Index(discriminator));
+    break;
+
+  case MacroRole::Accessor:
+    appendOperator("fMa", Index(discriminator));
+    break;
+
+  case MacroRole::MemberAttribute:
+    appendOperator("fMA", Index(discriminator));
+    break;
+
+  case MacroRole::Member:
+    appendOperator("fMm", Index(discriminator));
+    break;
+  }
 }
 
 std::string ASTMangler::mangleMacroExpansion(
@@ -3788,6 +3844,7 @@ std::string ASTMangler::mangleMacroExpansion(
   appendMacroExpansionContext(expansion->getLoc(), expansion->getDeclContext());
   appendMacroExpansionOperator(
       expansion->getMacroName().getBaseName().userFacingName(),
+      MacroRole::Expression,
       expansion->getDiscriminator());
   return finalize();
 }
@@ -3798,10 +3855,41 @@ std::string ASTMangler::mangleMacroExpansion(
   appendMacroExpansionContext(expansion->getLoc(), expansion->getDeclContext());
   appendMacroExpansionOperator(
       expansion->getMacro().getBaseName().userFacingName(),
+      MacroRole::Declaration,
       expansion->getDiscriminator());
   return finalize();
 }
 
+std::string ASTMangler::mangleAttachedMacroExpansion(
+    const Decl *decl, CustomAttr *attr, MacroRole role) {
+  beginMangling();
+
+  DeclContext *macroDeclContext = decl->getDeclContext();
+  if (role == MacroRole::MemberAttribute) {
+    appendContextOf(cast<ValueDecl>(decl));
+    macroDeclContext = decl->getDeclContext()->getParent();
+  } else if (auto valueDecl = dyn_cast<ValueDecl>(decl)) {
+    appendAnyDecl(valueDecl);
+  } else {
+    appendContext(decl->getDeclContext(), "");
+  }
+
+  StringRef macroName;
+  auto *macroDecl = evaluateOrDefault(
+      decl->getASTContext().evaluator,
+      ResolveMacroRequest{attr, role, macroDeclContext},
+      nullptr);
+  if (macroDecl)
+    macroName = macroDecl->getName().getBaseName().userFacingName();
+  else
+    macroName = "__unknown_macro__";
+
+  appendMacroExpansionOperator(
+      macroName, role,
+      decl->getAttachedMacroDiscriminator(role, attr));
+  return finalize();
+}
+
 static void gatherExistentialRequirements(SmallVectorImpl<Requirement> &reqs,
                                           ParameterizedProtocolType *PPT) {
   auto protoTy = PPT->getBaseType();

lib/AST/Decl.cpp

@@ -58,6 +58,7 @@
 #include "swift/Demangling/ManglingMacros.h"
 #include "swift/Parse/Lexer.h" // FIXME: Bad dependency
 #include "clang/Lex/MacroInfo.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
@@ -397,6 +398,33 @@ void Decl::forEachAttachedMacro(MacroRole role,
   }
 }
 
+unsigned Decl::getAttachedMacroDiscriminator(
+    MacroRole role, const CustomAttr *attr
+) const {
+  assert(isAttachedMacro(role) && "Not an attached macro role");
+
+  // Member-attribute macros are written on the enclosing declaration,
+  // but apply to the member itself. Adjust the owning declaration accordingly.
+  const Decl *owningDecl = this;
+  if (role == MacroRole::MemberAttribute) {
+    owningDecl = getDeclContext()->getAsDecl();
+  }
+
+  llvm::SmallDenseMap<Identifier, unsigned> nextDiscriminator;
+  Optional<unsigned> foundDiscriminator;
+
+  owningDecl->forEachAttachedMacro(
+    role,
+    [&](CustomAttr *foundAttr, MacroDecl *foundMacro) {
+      unsigned discriminator =
+        nextDiscriminator[foundMacro->getBaseIdentifier()]++;
+      if (attr == foundAttr)
+        foundDiscriminator = discriminator;
+    });
+
+  return *foundDiscriminator;
+}
+
 const Decl *Decl::getInnermostDeclWithAvailability() const {
   if (auto attrAndDecl = getSemanticAvailableRangeAttr())
     return attrAndDecl.value().second;

lib/Demangling/Demangler.cpp

@@ -3897,13 +3897,32 @@ NodePointer Demangler::demangleValueWitness() {
   return addChild(VW, popNode(Node::Kind::Type));
 }
 
+static bool isMacroExpansionNodeKind(Node::Kind kind) {
+  return kind == Node::Kind::AccessorAttachedMacroExpansion ||
+         kind == Node::Kind::MemberAttributeAttachedMacroExpansion ||
+         kind == Node::Kind::FreestandingMacroExpansion ||
+         kind == Node::Kind::MemberAttachedMacroExpansion;
+}
+
 NodePointer Demangler::demangleMacroExpansion() {
   Node::Kind kind;
   switch (nextChar()) {
+  case 'a':
+    kind = Node::Kind::AccessorAttachedMacroExpansion;
+    break;
+
+  case 'A':
+    kind = Node::Kind::MemberAttributeAttachedMacroExpansion;
+    break;
+
   case 'f':
     kind = Node::Kind::FreestandingMacroExpansion;
     break;
 
+  case 'm':
+    kind = Node::Kind::MemberAttachedMacroExpansion;
+    break;
+
   case 'u':
     kind = Node::Kind::MacroExpansionUniqueName;
     break;
@@ -3913,7 +3932,7 @@ NodePointer Demangler::demangleMacroExpansion() {
   }
 
   NodePointer name = popNode(Node::Kind::Identifier);
-  NodePointer context = popNode(Node::Kind::FreestandingMacroExpansion);
+  NodePointer context = popNode(isMacroExpansionNodeKind);
   if (!context)
     context = popContext();
   NodePointer discriminator = demangleIndexAsNode();

lib/Demangling/NodePrinter.cpp

@@ -340,6 +340,7 @@ class NodePrinter {
 
     case Node::Kind::PackExpansion:
     case Node::Kind::ProtocolListWithClass:
+    case Node::Kind::AccessorAttachedMacroExpansion:
     case Node::Kind::AccessorFunctionReference:
     case Node::Kind::Allocator:
     case Node::Kind::ArgumentTuple:
@@ -442,6 +443,8 @@ class NodePrinter {
     case Node::Kind::Macro:
     case Node::Kind::MacroExpansionUniqueName:
     case Node::Kind::MaterializeForSet:
+    case Node::Kind::MemberAttributeAttachedMacroExpansion:
+    case Node::Kind::MemberAttachedMacroExpansion:
     case Node::Kind::MergedFunction:
     case Node::Kind::Metaclass:
     case Node::Kind::MethodDescriptor:
@@ -1338,10 +1341,22 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
                        Node->getNumChildren() == 3? TypePrinting::WithColon
                                                   : TypePrinting::FunctionStyle,
                        /*hasName*/ true);
+  case Node::Kind::AccessorAttachedMacroExpansion:
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/true, "accessor macro expansion #",
+                       (int)Node->getChild(2)->getIndex() + 1);
   case Node::Kind::FreestandingMacroExpansion:
     return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
                        /*hasName*/true, "freestanding macro expansion #",
                        (int)Node->getChild(2)->getIndex() + 1);
+  case Node::Kind::MemberAttributeAttachedMacroExpansion:
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/true, "member attribute macro expansion #",
+                       (int)Node->getChild(2)->getIndex() + 1);
+  case Node::Kind::MemberAttachedMacroExpansion:
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/true, "member macro expansion #",
+                       (int)Node->getChild(2)->getIndex() + 1);
   case Node::Kind::MacroExpansionUniqueName:
     return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
                        /*hasName*/true, "unique name #",