[Macros] Add a mangling for macro expansions

DougGregor · DougGregor · commit 4ae434eaa17d · 2023-01-25T22:45:14.000-08:00
These aren't ABI, but are useful to provide consistent names to refer
to macro expansions, e.g., in buffer names.
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -365,6 +365,7 @@ Entities
   entity-spec ::= decl-name type 'fp'                                               // generic type parameter
   entity-spec ::= decl-name type 'fo'                                               // enum element (currently not used)
   entity-spec ::= decl-name label-list? type generic-signature? 'fm'   // macro
+  entity-spec ::= context macro-discriminator-list  // macro expansion
   entity-spec ::= identifier 'Qa'                                                   // associated type declaration
 
   ACCESSOR ::= 'm'                           // materializeForSet
@@ -392,6 +393,10 @@ Entities
   RELATED-DISCRIMINATOR ::= [a-j]
   RELATED-DISCRIMINATOR ::= [A-J]
 
+  macro-discriminator-list ::= macro-discriminator-list? 'fM' macro-expansion-operator INDEX
+
+  macro-expansion-operator ::= 'f' // freestanding macro
+
   file-discriminator ::= identifier 'Ll'     // anonymous file-discriminated declaration
 
 The identifier in a ``<file-discriminator>`` and the second identifier in a
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -1072,8 +1072,9 @@ class ASTContext final {
       llvm::SetVector<AutoDiffConfig> &results);
 
   /// Retrieve the next macro expansion discriminator within the given
-  /// context.
-  unsigned getNextMacroDiscriminator(MacroDiscriminatorContext context);
+  /// name and context.
+  unsigned getNextMacroDiscriminator(MacroDiscriminatorContext context,
+                                     DeclBaseName baseName);
 
   /// Retrieve the Clang module loader for this ASTContext.
   ///
diff --git a/include/swift/AST/ASTMangler.h b/include/swift/AST/ASTMangler.h
@@ -26,6 +26,7 @@ namespace swift {
 
 class AbstractClosureExpr;
 class ConformancePath;
+class MacroExpansionExpr;
 class RootProtocolConformance;
 
 namespace Mangle {
@@ -365,6 +366,12 @@ class ASTMangler : public Mangler {
   mangleRuntimeAttributeGeneratorEntity(const ValueDecl *decl, CustomAttr *attr,
                                         SymbolKind SKind = SymbolKind::Default);
 
+  std::string mangleMacroExpansion(const MacroExpansionExpr *expansion);
+  std::string mangleMacroExpansion(const MacroExpansionDecl *expansion);
+  void appendMacroExpansionContext(SourceLoc loc, DeclContext *origDC);
+  void appendMacroExpansionOperator(
+      StringRef macroName, unsigned discriminator);
+
   enum SpecialContext {
     ObjCContext,
     ClangImporterContext,
diff --git a/include/swift/Demangling/DemangleNodes.def b/include/swift/Demangling/DemangleNodes.def
@@ -148,6 +148,7 @@ NODE(LazyProtocolWitnessTableAccessor)
 NODE(LazyProtocolWitnessTableCacheVariable)
 NODE(LocalDeclName)
 NODE(Macro)
+NODE(MacroExpansion)
 CONTEXT_NODE(MaterializeForSet)
 NODE(MergedFunction)
 NODE(Metatype)
diff --git a/include/swift/Demangling/Demangler.h b/include/swift/Demangling/Demangler.h
@@ -589,6 +589,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleGenericRequirement();
   NodePointer demangleGenericType();
   NodePointer demangleValueWitness();
+  NodePointer demangleMacroExpansion();
 
   NodePointer demangleTypeMangling();
   NodePointer demangleSymbolicReference(unsigned char rawKind);
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -402,7 +402,8 @@ struct ASTContext::Implementation {
   llvm::DenseMap<const AbstractFunctionDecl *, SourceRange> OriginalBodySourceRanges;
 
   /// Macro discriminators per context.
-  llvm::DenseMap<const void *, unsigned> NextMacroDiscriminator;
+  llvm::DenseMap<std::pair<const void *, Identifier>, unsigned>
+      NextMacroDiscriminator;
 
   /// Structure that captures data that is segregated into different
   /// arenas.
@@ -2159,8 +2160,12 @@ void ASTContext::loadDerivativeFunctionConfigurations(
 }
 
 unsigned ASTContext::getNextMacroDiscriminator(
-    MacroDiscriminatorContext context) {
-  return getImpl().NextMacroDiscriminator[context.getOpaqueValue()]++;
+    MacroDiscriminatorContext context,
+    DeclBaseName baseName
+) {
+  std::pair<const void *, Identifier> key(
+      context.getOpaqueValue(), baseName.getIdentifier());
+  return getImpl().NextMacroDiscriminator[key]++;
 }
 
 void ASTContext::verifyAllLoadedModules() const {
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -18,7 +18,9 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/AutoDiff.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/ExistentialLayout.h"
+#include "swift/AST/Expr.h"
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Initializer.h"
@@ -32,6 +34,7 @@
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/Basic/Defer.h"
+#include "swift/Basic/SourceManager.h"
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
@@ -46,6 +49,7 @@
 #include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -3352,6 +3356,14 @@ void ASTMangler::appendEntity(const ValueDecl *decl) {
     return appendEntity(decl, "fp", decl->isStatic());
   if (auto macro = dyn_cast<MacroDecl>(decl))
     return appendEntity(decl, "fm", false);
+  if (auto expansion = dyn_cast<MacroExpansionDecl>(decl)) {
+    appendMacroExpansionContext(
+        expansion->getLoc(), expansion->getDeclContext());
+    appendMacroExpansionOperator(
+        expansion->getMacro().getBaseName().userFacingName(),
+        expansion->getDiscriminator());
+    return;
+  }
 
   assert(isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl));
 
@@ -3692,36 +3704,80 @@ void ASTMangler::appendMacroExpansionContext(
   if (!generatedSourceInfo)
     return appendContext(origDC, StringRef());
 
-  auto parent = MacroDiscriminatorContext::getParentOf(loc, origDC);
-  if (auto dc = parent.dyn_cast<DeclContext *>())
-    return appendContext(dc, StringRef());
-
   SourceLoc outerExpansionLoc;
+  DeclContext *outerExpansionDC;
+  DeclBaseName baseName;
   unsigned discriminator;
+  switch (generatedSourceInfo->kind) {
+  case GeneratedSourceInfo::ExpressionMacroExpansion: {
+    auto parent = ASTNode::getFromOpaqueValue(generatedSourceInfo->astNode);
+    if (auto expr =
+            cast_or_null<MacroExpansionExpr>(parent.dyn_cast<Expr *>())) {
+      outerExpansionLoc = expr->getLoc();
+      baseName = expr->getMacroName().getBaseName();
+      discriminator = expr->getDiscriminator();
+    } else {
+      auto decl = cast<MacroExpansionDecl>(parent.get<Decl *>());
+      outerExpansionLoc = decl->getLoc();
+      baseName = decl->getMacro().getBaseName();
+      discriminator = decl->getDiscriminator();
+    }
+    break;
+  }
 
-  if (auto expr = parent.dyn_cast<MacroExpansionExpr *>()) {
-    outerExpansionLoc = expr->getLoc();
-    discriminator = expr->getDiscriminator();
-  } else {
-    auto decl = parent.get<MacroExpansionDecl *>();
-    outerExpansionLoc = decl->getLoc();
-    discriminator = decl->getDiscriminator();
+  case GeneratedSourceInfo::FreestandingDeclMacroExpansion: {
+    auto expansion =
+        cast<MacroExpansionDecl>(
+          ASTNode::getFromOpaqueValue(generatedSourceInfo->astNode)
+            .get<Decl *>());
+    outerExpansionLoc = expansion->getLoc();
+    outerExpansionDC = expansion->getDeclContext();
+    discriminator = expansion->getDiscriminator();
+    break;
   }
 
+  case GeneratedSourceInfo::AccessorMacroExpansion:
+  case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+  case GeneratedSourceInfo::SynthesizedMemberMacroExpansion:
+  case GeneratedSourceInfo::PrettyPrinted:
+  case GeneratedSourceInfo::ReplacedFunctionBody:
+    return appendContext(origDC, StringRef());
+  }
+
+  // If we hit the point where the structure is represented as a DeclContext,
+  // we're done.
+  if (origDC->isChildContextOf(outerExpansionDC))
+    return appendContext(origDC, StringRef());
+
   // Append our own context and discriminator.
   appendMacroExpansionContext(outerExpansionLoc, origDC);
-  appendMacroExpansionOperator(discriminator);
+  appendMacroExpansionOperator(baseName.userFacingName(), discriminator);
 }
 
-void ASTMangler::appendMacroExpansionOperator(unsigned discriminator) {
-  appendOperator("fM", Index(discriminator));
+void ASTMangler::appendMacroExpansionOperator(
+    StringRef macroName, unsigned discriminator
+) {
+  appendIdentifier(macroName);
+  appendOperator("fMf", Index(discriminator));
 }
 
 std::string ASTMangler::mangleMacroExpansion(
     const MacroExpansionExpr *expansion) {
   beginMangling();
   appendMacroExpansionContext(expansion->getLoc(), expansion->getDeclContext());
-  appendMacroExpansionOperator(expansion->getDiscriminator());
+  appendMacroExpansionOperator(
+      expansion->getMacroName().getBaseName().userFacingName(),
+      expansion->getDiscriminator());
+  return finalize();
+}
+
+std::string ASTMangler::mangleMacroExpansion(
+    const MacroExpansionDecl *expansion) {
+  beginMangling();
+  appendMacroExpansionContext(expansion->getLoc(), expansion->getDeclContext());
+  appendMacroExpansionOperator(
+      expansion->getMacro().getBaseName().userFacingName(),
+      expansion->getDiscriminator());
   return finalize();
 }
 
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -9871,7 +9871,8 @@ unsigned MacroExpansionDecl::getDiscriminator() const {
   auto discriminatorContext =
       MacroDiscriminatorContext::getParentOf(mutableThis);
   mutableThis->setDiscriminator(
-      ctx.getNextMacroDiscriminator(discriminatorContext));
+      ctx.getNextMacroDiscriminator(
+          discriminatorContext, getMacro().getBaseName()));
 
   assert(getRawDiscriminator() != InvalidDiscriminator);
   return getRawDiscriminator();
@@ -9931,6 +9932,7 @@ MacroDiscriminatorContext MacroDiscriminatorContext::getParentOf(
 
   case GeneratedSourceInfo::AccessorMacroExpansion:
   case GeneratedSourceInfo::MemberAttributeMacroExpansion:
+  case GeneratedSourceInfo::SynthesizedMemberMacroExpansion:
   case GeneratedSourceInfo::PrettyPrinted:
   case GeneratedSourceInfo::ReplacedFunctionBody:
     return origDC;
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -2570,7 +2570,8 @@ unsigned MacroExpansionExpr::getDiscriminator() const {
   auto discriminatorContext =
       MacroDiscriminatorContext::getParentOf(mutableThis);
   mutableThis->setDiscriminator(
-      ctx.getNextMacroDiscriminator(discriminatorContext));
+      ctx.getNextMacroDiscriminator(
+          discriminatorContext, getMacroName().getBaseName()));
 
   assert(getRawDiscriminator() != InvalidDiscriminator);
   return getRawDiscriminator();
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -3590,6 +3590,7 @@ NodePointer Demangler::demangleFunctionEntity() {
       Kind = Node::Kind::RuntimeAttributeGenerator;
       break;
     case 'm': return demangleEntity(Node::Kind::Macro);
+    case 'M': return demangleMacroExpansion();
     case 'p': return demangleEntity(Node::Kind::GenericTypeParamDecl);
     case 'P':
       Args = None;
@@ -3889,3 +3890,20 @@ NodePointer Demangler::demangleValueWitness() {
   addChild(VW, createNode(Node::Kind::Index, unsigned(Kind)));
   return addChild(VW, popNode(Node::Kind::Type));
 }
+
+NodePointer Demangler::demangleMacroExpansion() {
+  Node::Kind kind;
+  switch (nextChar()) {
+  case 'f':
+    kind = Node::Kind::MacroExpansion;
+    break;
+
+  default:
+    return nullptr;
+  }
+
+  NodePointer name = popNode(Node::Kind::Identifier);
+  NodePointer context = popContext();
+  NodePointer discriminator = demangleIndexAsNode();
+  return createWithChildren(kind, context, name, discriminator);
+}
diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -439,6 +439,7 @@ class NodePrinter {
     case Node::Kind::LazyProtocolWitnessTableCacheVariable:
     case Node::Kind::LocalDeclName:
     case Node::Kind::Macro:
+    case Node::Kind::MacroExpansion:
     case Node::Kind::MaterializeForSet:
     case Node::Kind::MergedFunction:
     case Node::Kind::Metaclass:
@@ -1336,6 +1337,10 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
                        Node->getNumChildren() == 3? TypePrinting::WithColon
                                                   : TypePrinting::FunctionStyle,
                        /*hasName*/ true);
+  case Node::Kind::MacroExpansion:
+    return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
+                       /*hasName*/true, "macro expansion #",
+                       (int)Node->getChild(2)->getIndex() + 1);
   case Node::Kind::GenericTypeParamDecl:
     return printEntity(Node, depth, asPrefixContext, TypePrinting::NoType,
                        /*hasName*/ true);
@@ -3162,11 +3167,14 @@ NodePointer NodePrinter::printEntity(NodePointer Entity, unsigned depth,
   }
 
   if (hasName || !OverwriteName.empty()) {
-    assert(ExtraIndex < 0 && "Can't have a name and extra index");
     if (!ExtraName.empty() && MultiWordName) {
       Printer << ExtraName;
+      if (ExtraIndex >= 0)
+        Printer << ExtraIndex;
+
       Printer << " of ";
       ExtraName = "";
+      ExtraIndex = -1;
     }
     size_t CurrentPos = Printer.getStringRef().size();
     if (!OverwriteName.empty()) {
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
@@ -1063,6 +1063,12 @@ ManglingError Remangler::mangleMacro(Node *node, unsigned depth) {
   return mangleChildNodes(node, depth + 1);
 }
 
+ManglingError Remangler::mangleMacroExpansion(Node *node, unsigned depth) {
+  Buffer << "fMf";
+  RETURN_IF_ERROR(mangleIndex(node, depth + 1));
+  return mangleChildNodes(node, depth + 1);
+}
+
 ManglingError Remangler::mangleAccessor(Node *storageNode,
                                         StringRef accessorCode,
                                         EntityContext &ctx, unsigned depth) {
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -2868,6 +2868,13 @@ ManglingError Remangler::mangleMacro(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleMacroExpansion(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  Buffer << "fMf";
+  return mangleChildNode(node, 2, depth + 1);
+}
+
 ManglingError Remangler::mangleSuffix(Node *node, unsigned depth) {
   // Just add the suffix back on.
   Buffer << node->getText();
diff --git a/lib/Sema/TypeCheckMacros.cpp b/lib/Sema/TypeCheckMacros.cpp
@@ -18,6 +18,7 @@
 #include "TypeChecker.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTMangler.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/MacroDefinition.h"
@@ -468,24 +469,11 @@ Expr *swift::expandMacroExpr(
   // 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 = sourceFile->getBufferID()) {
-      unsigned startLine, startColumn;
-      std::tie(startLine, startColumn) =
-          sourceMgr.getLineAndColumnInBuffer(expr->getStartLoc(), *bufferID);
-
-      SourceLoc endLoc =
-          Lexer::getLocForEndOfToken(sourceMgr, expr->getEndLoc());
-      unsigned endLine, endColumn;
-      std::tie(endLine, endColumn) =
-          sourceMgr.getLineAndColumnInBuffer(endLoc, *bufferID);
-
-      out << ":" << sourceMgr.getIdentifierForBuffer(*bufferID) << ":"
-          << startLine << ":" << startColumn
-          << "-" << endLine << ":" << endColumn;
-    }
+    Mangle::ASTMangler mangler;
+    if (auto expansionExpr = dyn_cast<MacroExpansionExpr>(expr))
+      bufferName = mangler.mangleMacroExpansion(expansionExpr);
+    else
+      bufferName = "<macro expansion>";
   }
 
   // Dump macro expansions to standard output, if requested.
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -139,7 +139,7 @@ enum class TypeCheckExprFlags {
   /// Don't type check expressions for correct availability.
   DisableExprAvailabilityChecking = 0x08,
 
-  /// Don't expansino macros.
+  /// Don't expand macros.
   DisableMacroExpansions = 0x10,
 };
 
diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt
