Merge pull request swiftlang#63233 from DougGregor/macros-mangle-buffer-names

[Macros] Mangle the names of macro expansion buffers

Author: DougGregor

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

include/swift/AST/ASTContext.h

@@ -87,6 +87,7 @@ namespace swift {
   class LazyContextData;
   class LazyIterableDeclContextData;
   class LazyMemberLoader;
+  struct MacroDiscriminatorContext;
   class ModuleDependencyInfo;
   class PatternBindingDecl;
   class PatternBindingInitializer;
@@ -1070,6 +1071,11 @@ class ASTContext final {
       AbstractFunctionDecl *originalAFD, unsigned previousGeneration,
       llvm::SetVector<AutoDiffConfig> &results);
 
+  /// Retrieve the next macro expansion discriminator within the given
+  /// name and context.
+  unsigned getNextMacroDiscriminator(MacroDiscriminatorContext context,
+                                     DeclBaseName baseName);
+
   /// Retrieve the Clang module loader for this ASTContext.
   ///
   /// If there is no Clang module loader, returns a null pointer.

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,

include/swift/AST/Decl.h

@@ -725,6 +725,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     NumberOfVTableEntries : 2
   );
 
+  SWIFT_INLINE_BITFIELD(MacroExpansionDecl, Decl, 16,
+    Discriminator : 16
+  );
+
   } Bits;
 
   // Storage for the declaration attributes.
@@ -8454,6 +8458,8 @@ class MacroExpansionDecl : public Decl {
   ConcreteDeclRef macroRef;
 
 public:
+  enum : unsigned { InvalidDiscriminator = 0xFFFF };
+
   MacroExpansionDecl(DeclContext *dc, SourceLoc poundLoc, DeclNameRef macro,
                      DeclNameLoc macroLoc,
                      SourceLoc leftAngleLoc,
@@ -8463,7 +8469,9 @@ class MacroExpansionDecl : public Decl {
       : Decl(DeclKind::MacroExpansion, dc), PoundLoc(poundLoc),
         Macro(macro), MacroLoc(macroLoc),
         LeftAngleLoc(leftAngleLoc), RightAngleLoc(rightAngleLoc),
-        GenericArgs(genericArgs), ArgList(args), Rewritten({}) {}
+        GenericArgs(genericArgs), ArgList(args), Rewritten({}) {
+    Bits.MacroExpansionDecl.Discriminator = InvalidDiscriminator;
+  }
 
   ArrayRef<TypeRepr *> getGenericArgs() const { return GenericArgs; }
 
@@ -8482,6 +8490,24 @@ class MacroExpansionDecl : public Decl {
   ConcreteDeclRef getMacroRef() const { return macroRef; }
   void setMacroRef(ConcreteDeclRef ref) { macroRef = ref; }
 
+  /// Returns a discriminator which determines this macro expansion's index
+  /// in the sequence of macro expansions within the current function.
+  unsigned getDiscriminator() const;
+
+  /// Retrieve the raw discriminator, which may not have been computed yet.
+  ///
+  /// Only use this for queries that are checking for (e.g.) reentrancy or
+  /// intentionally do not want to initiate verification.
+  unsigned getRawDiscriminator() const {
+    return Bits.MacroExpansionDecl.Discriminator;
+  }
+
+  void setDiscriminator(unsigned discriminator) {
+    assert(getRawDiscriminator() == InvalidDiscriminator);
+    assert(discriminator != InvalidDiscriminator);
+    Bits.MacroExpansionDecl.Discriminator = discriminator;
+  }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::MacroExpansion;
   }

include/swift/AST/Expr.h

@@ -363,6 +363,12 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     : NumPadBits,
     NumElements : 32
   );
+
+  SWIFT_INLINE_BITFIELD(MacroExpansionExpr, Expr, (16-NumExprBits)+16,
+    : 16 - NumExprBits, // Align and leave room for subclasses
+    Discriminator : 16
+  );
+
   } Bits;
 
 private:
@@ -6047,6 +6053,7 @@ class TypeJoinExpr final : public Expr,
 
 class MacroExpansionExpr final : public Expr {
 private:
+  DeclContext *DC;
   SourceLoc PoundLoc;
   DeclNameRef MacroName;
   DeclNameLoc MacroNameLoc;
@@ -6059,19 +6066,26 @@ class MacroExpansionExpr final : public Expr {
   ConcreteDeclRef macroRef;
 
 public:
-  explicit MacroExpansionExpr(SourceLoc poundLoc, DeclNameRef macroName,
+  enum : unsigned { InvalidDiscriminator = 0xFFFF };
+
+  explicit MacroExpansionExpr(DeclContext *dc,
+                              SourceLoc poundLoc, DeclNameRef macroName,
                               DeclNameLoc macroNameLoc,
                               SourceLoc leftAngleLoc,
                               ArrayRef<TypeRepr *> genericArgs,
                               SourceLoc rightAngleLoc,
-                              ArgumentList *argList, bool isImplicit = false,
+                              ArgumentList *argList,
+                              bool isImplicit = false,
                               Type ty = Type())
-      : Expr(ExprKind::MacroExpansion, isImplicit, ty), PoundLoc(poundLoc),
+      : Expr(ExprKind::MacroExpansion, isImplicit, ty),
+        DC(dc), PoundLoc(poundLoc),
         MacroName(macroName), MacroNameLoc(macroNameLoc),
         LeftAngleLoc(leftAngleLoc), RightAngleLoc(rightAngleLoc),
         GenericArgs(genericArgs),
         ArgList(argList),
-        Rewritten(nullptr) { }
+        Rewritten(nullptr) {
+    Bits.MacroExpansionExpr.Discriminator = InvalidDiscriminator;
+  }
 
   DeclNameRef getMacroName() const { return MacroName; }
   DeclNameLoc getMacroNameLoc() const { return MacroNameLoc; }
@@ -6093,6 +6107,27 @@ class MacroExpansionExpr final : public Expr {
   ConcreteDeclRef getMacroRef() const { return macroRef; }
   void setMacroRef(ConcreteDeclRef ref) { macroRef = ref; }
 
+  DeclContext *getDeclContext() const { return DC; }
+  void setDeclContext(DeclContext *dc) { DC = dc; }
+
+  /// Returns a discriminator which determines this macro expansion's index
+  /// in the sequence of macro expansions within the current function.
+  unsigned getDiscriminator() const;
+
+  /// Retrieve the raw discriminator, which may not have been computed yet.
+  ///
+  /// Only use this for queries that are checking for (e.g.) reentrancy or
+  /// intentionally do not want to initiate verification.
+  unsigned getRawDiscriminator() const {
+    return Bits.MacroExpansionExpr.Discriminator;
+  }
+
+  void setDiscriminator(unsigned discriminator) {
+    assert(getRawDiscriminator() == InvalidDiscriminator);
+    assert(discriminator != InvalidDiscriminator);
+    Bits.MacroExpansionExpr.Discriminator = discriminator;
+  }
+
   SourceRange getSourceRange() const;
 
   static bool classof(const Expr *E) {

include/swift/AST/MacroDiscriminatorContext.h

@@ -0,0 +1,38 @@
+//===--- MacroDiscriminatorContext.h - Macro Discriminators -----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_MACRO_DISCRIMINATOR_CONTEXT_H
+#define SWIFT_AST_MACRO_DISCRIMINATOR_CONTEXT_H
+
+#include "swift/AST/Decl.h"
+#include "swift/AST/Expr.h"
+#include "llvm/ADT/PointerUnion.h"
+
+namespace swift {
+
+/// Describes the context of a macro expansion for the purpose of
+/// computing macro expansion discriminators.
+struct MacroDiscriminatorContext
+    : public llvm::PointerUnion<DeclContext *, MacroExpansionExpr *,
+                                MacroExpansionDecl *> {
+  using PointerUnion::PointerUnion;
+
+  static MacroDiscriminatorContext getParentOf(MacroExpansionExpr *expansion);
+  static MacroDiscriminatorContext getParentOf(MacroExpansionDecl *expansion);
+  static MacroDiscriminatorContext getParentOf(
+      SourceLoc loc, DeclContext *origDC
+  );
+};
+
+}
+
+#endif // SWIFT_AST_MACRO_DISCRIMINATOR_CONTEXT_H

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)

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);

lib/AST/ASTContext.cpp

@@ -35,6 +35,7 @@
 #include "swift/AST/IndexSubset.h"
 #include "swift/AST/KnownProtocols.h"
 #include "swift/AST/LazyResolver.h"
+#include "swift/AST/MacroDiscriminatorContext.h"
 #include "swift/AST/ModuleDependencies.h"
 #include "swift/AST/ModuleLoader.h"
 #include "swift/AST/NameLookup.h"
@@ -400,6 +401,10 @@ struct ASTContext::Implementation {
   /// is populated if the body is reparsed from other source buffers.
   llvm::DenseMap<const AbstractFunctionDecl *, SourceRange> OriginalBodySourceRanges;
 
+  /// Macro discriminators per context.
+  llvm::DenseMap<std::pair<const void *, Identifier>, unsigned>
+      NextMacroDiscriminator;
+
   /// Structure that captures data that is segregated into different
   /// arenas.
   struct Arena {
@@ -2154,6 +2159,15 @@ void ASTContext::loadDerivativeFunctionConfigurations(
   }
 }
 
+unsigned ASTContext::getNextMacroDiscriminator(
+    MacroDiscriminatorContext context,
+    DeclBaseName baseName
+) {
+  std::pair<const void *, Identifier> key(
+      context.getOpaqueValue(), baseName.getIdentifier());
+  return getImpl().NextMacroDiscriminator[key]++;
+}
+
 void ASTContext::verifyAllLoadedModules() const {
 #ifndef NDEBUG
   FrontendStatsTracer tracer(Stats, "verify-all-loaded-modules");

lib/AST/ASTDumper.cpp

@@ -3021,6 +3021,8 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
   void visitMacroExpansionExpr(MacroExpansionExpr *E) {
     printCommon(E, "macro_expansion_expr");
     PrintWithColorRAII(OS, IdentifierColor) << " name=" << E->getMacroName();
+    PrintWithColorRAII(OS, DiscriminatorColor)
+      << " discriminator=" << E->getRawDiscriminator();
     if (E->getArgs()) {
       OS << '\n';
       printArgumentList(E->getArgs());