[Macros] Implement AST printing and module interface generation for macros

Author: DougGregor

include/swift/AST/Decl.h

@@ -8316,6 +8316,9 @@ class MacroDecl : public GenericContext, public ValueDecl {
 
   SourceRange getSourceRange() const;
 
+  /// Retrieve the interface type produced when expanding this macro.
+  Type getResultInterfaceType() const;
+
   static bool classof(const DeclContext *C) {
     if (auto D = C->getAsDecl())
       return classof(D);

lib/AST/ASTPrinter.cpp

@@ -1899,10 +1899,6 @@ bool ShouldPrintChecker::shouldPrint(const Decl *D,
       return true;
   }
 
-  // Skip macros, which don't have an in-source representation.
-  if (isa<MacroDecl>(D))
-    return false;
-
   // Skip declarations that are not accessible.
   if (auto *VD = dyn_cast<ValueDecl>(D)) {
     if (Options.AccessFilter > AccessLevel::Private &&
@@ -2738,7 +2734,7 @@ static bool usesFeatureActors(Decl *decl) {
 }
 
 static bool usesFeatureMacros(Decl *decl) {
-  return isa<MacroExpansionDecl>(decl);
+  return isa<MacroExpansionDecl>(decl) || isa<MacroDecl>(decl);
 }
 
 static bool usesFeatureConcurrentFunctions(Decl *decl) {
@@ -4446,7 +4442,59 @@ void PrintAST::visitMissingMemberDecl(MissingMemberDecl *decl) {
 }
 
 void PrintAST::visitMacroDecl(MacroDecl *decl) {
-  // No in-source representation of macros.
+  printDocumentationComment(decl);
+  printAttributes(decl);
+  printAccess(decl);
+
+  Printer.printIntroducerKeyword("macro", Options, " ");
+  printContextIfNeeded(decl);
+
+  recordDeclLoc(
+      decl,
+      [&]{
+        Printer.printName(
+            decl->getBaseIdentifier(),
+            getTypeMemberPrintNameContext(decl));
+      },
+      [&] {
+        printGenericDeclGenericParams(decl);
+        if (decl->parameterList) {
+          auto params = ArrayRef<AnyFunctionType::Param>();
+          if (!decl->isInvalid()) {
+            // Walk to the params of the subscript's indices.
+            auto type = decl->getInterfaceType();
+            params = type->castTo<AnyFunctionType>()->getParams();
+          }
+          printParameterList(
+              decl->parameterList, params, /*isAPINameByDefault*/true);
+        }
+      }
+  );
+
+  {
+    Printer.printStructurePre(PrintStructureKind::DeclResultTypeClause);
+    SWIFT_DEFER {
+      Printer.printStructurePost(PrintStructureKind::DeclResultTypeClause);
+    };
+
+    if (decl->parameterList)
+      Printer << " -> ";
+    else
+      Printer << ": ";
+
+    TypeLoc resultTypeLoc(
+        decl->resultType.getTypeRepr(), decl->getResultInterfaceType());
+
+    Printer.printDeclResultTypePre(decl, resultTypeLoc);
+    Printer.callPrintStructurePre(PrintStructureKind::FunctionReturnType);
+    printTypeLocWithOptions(resultTypeLoc, Options);
+    Printer.printStructurePost(PrintStructureKind::FunctionReturnType);
+  }
+
+  Printer << " = ";
+  Printer << decl->externalModuleName << "." << decl->externalMacroTypeName;
+
+  printDeclGenericRequirements(decl);
 }
 
 void PrintAST::visitMacroExpansionDecl(MacroExpansionDecl *decl) {

lib/AST/Decl.cpp

@@ -9654,6 +9654,16 @@ MacroDecl::MacroDecl(
     parameterList->setDeclContextOfParamDecls(this);
 }
 
+Type MacroDecl::getResultInterfaceType() const {
+  auto &ctx = getASTContext();
+  auto mutableThis = const_cast<MacroDecl *>(this);
+  if (auto type = evaluateOrDefault(ctx.evaluator,
+                           ResultTypeRequest{mutableThis},
+                           Type()))
+    return type;
+  return ErrorType::get(ctx);
+}
+
 SourceRange MacroDecl::getSourceRange() const {
   return SourceRange(macroLoc, externalMacroTypeNameLoc);
 }

lib/Sema/TypeCheckDecl.cpp

@@ -2550,8 +2550,7 @@ InterfaceTypeRequest::evaluate(Evaluator &eval, ValueDecl *D) const {
 
   case DeclKind::Macro: {
     auto macro = cast<MacroDecl>(D);
-    Type resultType = evaluateOrDefault(
-        Context.evaluator, ResultTypeRequest{macro}, ErrorType::get(Context));
+    Type resultType = macro->getResultInterfaceType();
     if (!macro->parameterList)
       return resultType;
 

lib/Serialization/Serialization.cpp

@@ -4314,10 +4314,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     uint8_t rawAccessLevel =
       getRawStableAccessLevel(macro->getFormalAccess());
 
-    Type resultType = evaluateOrDefault(
-        S.getASTContext().evaluator,
-        ResultTypeRequest{const_cast<MacroDecl *>(macro)},
-        Type());
+    Type resultType = macro->getResultInterfaceType();
 
     unsigned abbrCode = S.DeclTypeAbbrCodes[MacroLayout::Code];
     MacroLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,

test/ModuleInterface/macros.swift

@@ -0,0 +1,18 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend -typecheck -module-name Macros -emit-module-interface-path %t/Macros.swiftinterface -enable-experimental-feature Macros %s
+// RUN: %FileCheck %s < %t/Macros.swiftinterface --check-prefix CHECK
+// RUN: %target-swift-frontend -compile-module-from-interface %t/Macros.swiftinterface -o %t/Macros.swiftmodule
+
+// CHECK: #if compiler(>=5.3) && $Macros
+// CHECK-NEXT: public macro publicStringify<T>(_ value: T) -> (T, Swift.String) = _SwiftSyntaxMacros.StringifyMacro
+// CHECK-NEXT: #endif
+public macro publicStringify<T>(_ value: T) -> (T, String) = _SwiftSyntaxMacros.StringifyMacro
+
+// CHECK: #if compiler(>=5.3) && $Macros
+// CHECK: public macro publicLine<T>: T = _SwiftSyntaxMacros.Line where T : Swift.ExpressibleByIntegerLiteral
+// CHECK-NEXT: #endif
+public macro publicLine<T: ExpressibleByIntegerLiteral>: T = _SwiftSyntaxMacros.Line
+
+// CHECK-NOT: internalStringify
+macro internalStringify<T>(_ value: T) -> (T, String) = _SwiftSyntaxMacros.StringifyMacro