[Macros] Start recording expanded macro definitions and replacements

Handle a trivial macro defined in terms of another macro.

Author: DougGregor

include/swift/AST/MacroDefinition.h

@@ -22,6 +22,8 @@
 
 namespace swift {
 
+class ASTContext;
+
 /// A reference to an external macro definition that is understood by ASTGen.
 struct ExternalMacroDefinition {
   enum class PluginKind {
@@ -46,6 +48,35 @@ enum class BuiltinMacroKind: uint8_t {
   ExternalMacro,
 };
 
+/// A single replacement
+struct ExpandedMacroReplacement {
+  unsigned startOffset, endOffset;
+  unsigned parameterIndex;
+};
+
+/// An expansion of another macro.
+class ExpandedMacroDefinition {
+  friend class MacroDefinition;
+
+  /// The expansion text, ASTContext-allocated.
+  StringRef expansionText;
+
+  /// The macro replacements, ASTContext-allocated.
+  ArrayRef<ExpandedMacroReplacement> replacements;
+
+  ExpandedMacroDefinition(
+    StringRef expansionText,
+    ArrayRef<ExpandedMacroReplacement> replacements
+  ) : expansionText(expansionText), replacements(replacements) { }
+
+public:
+  StringRef getExpansionText() const { return expansionText; }
+
+  ArrayRef<ExpandedMacroReplacement> getReplacements() const {
+    return replacements;
+  }
+};
+
 /// Provides the definition of a macro.
 class MacroDefinition {
 public:
@@ -63,6 +94,9 @@ class MacroDefinition {
 
     /// A builtin macro definition, which has a separate builtin kind.
     Builtin,
+
+    /// A macro that is defined as an expansion of another macro.
+    Expanded,
   };
 
   Kind kind;
@@ -71,6 +105,7 @@ class MacroDefinition {
   union Data {
     ExternalMacroReference external;
     BuiltinMacroKind builtin;
+    ExpandedMacroDefinition expanded;
 
     Data() : builtin(BuiltinMacroKind::ExternalMacro) { }
   } data;
@@ -85,6 +120,10 @@ class MacroDefinition {
     data.builtin = builtinKind;
   }
 
+  MacroDefinition(ExpandedMacroDefinition expanded) : kind(Kind::Expanded) {
+    data.expanded = expanded;
+  }
+
 public:
   static MacroDefinition forInvalid() {
     return MacroDefinition(Kind::Invalid);
@@ -105,6 +144,13 @@ class MacroDefinition {
     return MacroDefinition(builtinKind);
   }
 
+  /// Create a representation of an expanded macro definition.
+  static MacroDefinition forExpanded(
+      ASTContext &ctx,
+      StringRef expansionText,
+      ArrayRef<ExpandedMacroReplacement> replacements
+  );
+
   /// Retrieve the external macro being referenced.
   ExternalMacroReference getExternalMacro() const {
     assert(kind == Kind::External);
@@ -117,6 +163,11 @@ class MacroDefinition {
     return data.builtin;
   }
 
+  ExpandedMacroDefinition getExpanded() const {
+    assert(kind == Kind::Expanded);
+    return data.expanded;
+  }
+
   operator Kind() const { return kind; }
 };
 

include/swift/Basic/StringExtras.h

@@ -490,7 +490,7 @@ class NullTerminatedStringRef {
 
   /// Create a null-terminated string, copying \p Str into \p A .
   template <typename Allocator>
-  NullTerminatedStringRef(StringRef Str, Allocator &A) : Ref("") {
+  NullTerminatedStringRef(StringRef Str, Allocator &A) : Ref() {
     if (Str.empty())
       return;
 

lib/AST/ASTMangler.cpp

@@ -3869,12 +3869,14 @@ void ASTMangler::appendMacroExpansionContext(
       baseName = expr->getMacroName().getBaseName();
       discriminator = expr->getDiscriminator();
       role = MacroRole::Expression;
+      outerExpansionDC = expr->getDeclContext();
     } else {
       auto decl = cast<MacroExpansionDecl>(parent.get<Decl *>());
       outerExpansionLoc = decl->getLoc();
       baseName = decl->getMacroName().getBaseName();
       discriminator = decl->getDiscriminator();
       role = MacroRole::Declaration;
+      outerExpansionDC = decl->getDeclContext();
     }
     break;
   }

lib/AST/ASTPrinter.cpp

@@ -4711,6 +4711,10 @@ void PrintAST::visitMacroDecl(MacroDecl *decl) {
         break;
       }
       break;
+
+    case MacroDefinition::Kind::Expanded:
+      Printer << " = " << def.getExpanded().getExpansionText();
+      break;
     }
   }
 

lib/AST/Decl.cpp

@@ -10315,6 +10315,15 @@ Optional<BuiltinMacroKind> MacroDecl::getBuiltinKind() const {
   return def.getBuiltinKind();
 }
 
+MacroDefinition MacroDefinition::forExpanded(
+    ASTContext &ctx,
+    StringRef expansionText,
+    ArrayRef<ExpandedMacroReplacement> replacements
+) {
+  return ExpandedMacroDefinition{ctx.AllocateCopy(expansionText),
+                                 ctx.AllocateCopy(replacements)};
+}
+
 MacroExpansionDecl::MacroExpansionDecl(
     DeclContext *dc, SourceLoc poundLoc, DeclNameRef macro,
     DeclNameLoc macroLoc, SourceLoc leftAngleLoc,

lib/AST/DistributedDecl.cpp

@@ -56,7 +56,6 @@
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 
-#include "InlinableText.h"
 #include <algorithm>
 
 using namespace swift;

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -314,7 +314,7 @@ func checkMacroDefinition(
       )
       return BridgedMacroDefinitionKind.externalMacro.rawValue
 
-    case let .expansion(expansionSyntax, replacements: replacements)
+    case let .expansion(expansionSyntax, replacements: _)
         where expansionSyntax.macro.text == "externalMacro":
       // Extract the identifier from the "module" argument.
       guard let firstArg = expansionSyntax.argumentList.first,
@@ -354,6 +354,12 @@ func checkMacroDefinition(
       return BridgedMacroDefinitionKind.externalMacro.rawValue
 
     case let .expansion(expansionSyntax, replacements: replacements):
+      // Provide the expansion syntax.
+      (externalMacroPointer.pointee, externalMacroLength.pointee) =
+        allocateUTF8String(expansionSyntax.trimmedDescription,
+                           nullTerminated: true)
+
+
       // If there are no replacements, we're done.
       if replacements.isEmpty {
         return BridgedMacroDefinitionKind.expandedMacro.rawValue

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2053,6 +2053,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     case MacroDefinition::Kind::Invalid:
     case MacroDefinition::Kind::Builtin:
+    case MacroDefinition::Kind::Expanded:
       // Nothing else to check here.
       break;