[Macros] Adapt to macro API changes and switch more testing to use it.

The API provided by macro evaluation has changed a bit. Adapt ASTGen to
the new API, and use this as an opportunity to start moving more tests
to using the shared libraries built into the toolchain.

Author: DougGregor

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -1,6 +1,6 @@
 import SwiftParser
 import SwiftSyntax
-import _SwiftSyntaxMacros
+@_spi(Testing) import _SwiftSyntaxMacros
 
 extension SyntaxProtocol {
   func token(at position: AbsolutePosition) -> TokenSyntax? {
@@ -82,6 +82,18 @@ private func allocateUTF8String(
   }
 }
 
+extension String {
+  /// Drop everything up to and including the last '/' from the string.
+  fileprivate func withoutPath() -> String {
+    // Only keep everything after the last slash.
+    if let lastSlash = lastIndex(of: "/") {
+      return String(self[index(after: lastSlash)...])
+    }
+
+    return self
+  }
+}
+
 @_cdecl("swift_ASTGen_evaluateMacro")
 @usableFromInline
 func evaluateMacro(
@@ -124,12 +136,9 @@ func evaluateMacro(
       return -1
     }
 
-    let converter = SourceLocationConverter(
-      file: sourceFile.pointee.fileName, tree: sf
-    )
-    let context = MacroEvaluationContext(
+    var context = MacroExpansionContext(
       moduleName: sourceFile.pointee.moduleName,
-      sourceLocationConverter: converter
+      fileName: sourceFile.pointee.fileName.withoutPath()
     )
 
     let evaluatedSyntax: ExprSyntax = macroPtr.withMemoryRebound(to: ExportedMacro.self, capacity: 1) { macro in
@@ -138,11 +147,11 @@ func evaluateMacro(
         return ExprSyntax(parentExpansion)
       }
 
-      let expansion = exprMacro.apply(parentExpansion, in: context)
-      // FIXME: Produce diagnostics.
-      return expansion.rewritten
+      return exprMacro.expand(parentExpansion, in: &context)
     }
 
+    // FIXME: Emit diagnostics accumulated in the
+
     var evaluatedSyntaxStr = evaluatedSyntax.withoutTrivia().description
     evaluatedSyntaxStr.withUTF8 { utf8 in
       let evaluatedResultPtr = UnsafeMutablePointer<UInt8>.allocate(capacity: utf8.count + 1)
@@ -158,16 +167,3 @@ func evaluateMacro(
     return 0
   }
 }
-
-// Makes sure that the type metadata for these macros can be found.
-public var allBuiltinMacros: [Any.Type] = [
-  ColorLiteralMacro.self,
-  ColumnMacro.self,
-  FileIDMacro.self,
-  FileLiteralMacro.self,
-  FilePathMacro.self,
-  FunctionMacro.self,
-  ImageLiteralMacro.self,
-  LineMacro.self,
-  StringifyMacro.self
-]

lib/Sema/TypeCheckMacros.cpp

@@ -101,21 +101,19 @@ MacroDefinition MacroDefinitionRequest::evaluate(
   ASTContext &ctx = macro->getASTContext();
 
 #if SWIFT_SWIFT_PARSER
-
   /// Look for the type metadata given the external module and type names.
   auto macroMetatype = lookupMacroTypeMetadataByExternalName(
       ctx, macro->externalModuleName.str(),
       macro->externalMacroTypeName.str());
   if (macroMetatype) {
     // Check whether the macro metatype can be handled as a compiler plugin.
-    // We look here first, because compiler plugins are meant to be resilient.
     if (auto plugin = CompilerPlugin::fromMetatype(macroMetatype, ctx)) {
       // FIXME: Handle other kinds of macros.
       return MacroDefinition::forCompilerPlugin(
           MacroDefinition::Expression, plugin);
     }
 
-    // Otherwise, check whether the macro metatype can be handled as a builtin.
+    // Check whether the macro metatype can be handled as a builtin.
     if (auto builtin = swift_ASTGen_resolveMacroType(macroMetatype)) {
       // Make sure we clean up after the macro.
       ctx.addCleanup([builtin]() {

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -2,23 +2,55 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 import _SwiftSyntaxMacros
 
-public struct FileIDMacro: ExpressionMacro {
-  public static func apply(
-    _ macro: MacroExpansionExprSyntax, in context: MacroEvaluationContext
-  ) -> MacroResult<ExprSyntax> {
-    var fileName = context.sourceLocationConverter.location(
-      for: .init(utf8Offset: 0)
-    ).file ?? "<unknown file>"
+/// Replace the label of the first element in the tuple with the given
+/// new label.
+private func replaceFirstLabel(
+  of tuple: TupleExprElementListSyntax, with newLabel: String
+) -> TupleExprElementListSyntax{
+  guard let firstElement = tuple.first else {
+    return tuple
+  }
+
+  return tuple.replacing(
+    childAt: 0, with: firstElement.withLabel(.identifier(newLabel)))
+}
 
-    // Only keep everything after the last slash.
-    if let lastSlash = fileName.lastIndex(of: "/") {
-      fileName = String(fileName[fileName.index(after: lastSlash)...])
+public struct ColorLiteralMacro: ExpressionMacro {
+  public static func expand(
+    _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
+  ) -> ExprSyntax {
+    let argList = replaceFirstLabel(
+      of: macro.argumentList, with: "_colorLiteralRed"
+    )
+    let initSyntax: ExprSyntax = ".init(\(argList))"
+    if let leadingTrivia = macro.leadingTrivia {
+      return initSyntax.withLeadingTrivia(leadingTrivia)
     }
+    return initSyntax
+  }
+}
 
-    let fileLiteral: ExprSyntax = #""\#(context.moduleName)/\#(fileName)""#
+public struct FileIDMacro: ExpressionMacro {
+  public static func expand(
+    _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
+  ) -> ExprSyntax {
+    let fileLiteral: ExprSyntax = #""\#(context.moduleName)/\#(context.fileName)""#
     if let leadingTrivia = macro.leadingTrivia {
-      return MacroResult(fileLiteral.withLeadingTrivia(leadingTrivia))
+      return fileLiteral.withLeadingTrivia(leadingTrivia)
+    }
+    return fileLiteral
+  }
+}
+
+public struct StringifyMacro: ExpressionMacro {
+  public static func expand(
+    _ macro: MacroExpansionExprSyntax, in context: inout MacroExpansionContext
+  ) -> ExprSyntax {
+    guard let argument = macro.argumentList.first?.expression else {
+      // FIXME: Create a diagnostic for the missing argument?
+      return ExprSyntax(macro)
     }
-    return MacroResult(fileLiteral)
+
+    return "(\(argument), \(StringLiteralExprSyntax(content: argument.description)))"
   }
 }

test/Macros/macro_external_exec.swift

@@ -1,5 +1,6 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-build-swift -Xfrontend -disable-availability-checking -I %swift-host-lib-dir -L %swift-host-lib-dir -emit-library -emit-library-path=%t/%target-library-name(MacroDefinition) -working-directory=%t -module-name=MacroDefinition %S/Inputs/syntax_macro_definitions.swift
+// RUN: %target-build-swift -I %swift-host-lib-dir -L %swift-host-lib-dir -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %S/Inputs/syntax_macro_definitions.swift -g -no-toolchain-stdlib-rpath
+// RUNx: %target-swift-frontend -dump-ast -enable-experimental-feature Macros -load-plugin-library %t/%target-library-name(MacroDefinition) -I %swift-host-lib-dir %s -module-name MacroUser 2>&1 | %FileCheck --check-prefix CHECK-AST %s
 // RUN: %target-build-swift -enable-experimental-feature Macros -load-plugin-library %t/%target-library-name(MacroDefinition) -I %swift-host-lib-dir -L %swift-host-lib-dir %s -o %t/main -module-name MacroUser
 // RUN: %target-run %t/main | %FileCheck %s
 // REQUIRES: executable_test
@@ -8,10 +9,29 @@
 // REQUIRES: OS=macosx
 
 macro customFileID: String = MacroDefinition.FileIDMacro
+macro stringify<T>(_ value: T) -> (T, String) = MacroDefinition.StringifyMacro
 
-func testFunc(a: Int, b: Int) {
+func testFileID(a: Int, b: Int) {
   // CHECK: MacroUser/macro_external_exec.swift
   print("Result is \(#customFileID)")
 }
 
-testFunc(a: 1, b: 2)
+testFileID(a: 1, b: 2)
+
+func testStringify(a: Int, b: Int) {
+  let s = #stringify(a + b)
+
+  // CHECK-AST: macro_expansion_expr type='(Int, String)'{{.*}}name=stringify
+  // CHECK-AST-NEXT: argument_list
+  // CHECK-AST: tuple_expr type='(Int, String)' location=Macro expansion of #stringify
+
+  let (b, s2) = #stringify({ () -> Bool in return true })
+  // CHECK-AST: macro_expansion_expr type='(() -> Bool, String)'{{.*}}name=stringify
+  // CHECK-AST-NEXT: argument_list
+  // CHECK-AST: tuple_expr type='(() -> Bool, String)' location=Macro expansion of #stringify
+
+  let (b2, s3) = #stringify<Double>(1 + 2)
+  // CHECK-AST: macro_expansion_expr type='(Double, String)'{{.*}}name=stringify
+  // CHECK-AST-NEXT: argument_list
+  // CHECK-AST: tuple_expr type='(Double, String)' location=Macro expansion of #stringify
+}