[Macros] "Expand" builtin macros for magic literals.

Introduce an experimental option `BuiltinMacros` that takes the magic
literals (`#file`, `#line`, `#function`, etc.) after type checking and
processes the original source for the expression using the build
syntactic macro system in the swift-syntax library. At present, the
result of expansion is printed to standard output, but it's enough to
verify that we're able to find the corresponding syntax node based on
the C++ AST.

Author: DougGregor

include/swift/Basic/Features.def

@@ -145,8 +145,13 @@ EXPERIMENTAL_FEATURE(ImplicitSome)
 /// corresponding syntax tree.
 EXPERIMENTAL_FEATURE(ParserASTGen)
 
+/// Enable the experimental macros feature.
 EXPERIMENTAL_FEATURE(Macros)
 
+/// Parse using the Swift (swift-syntax) parser and use ASTGen to generate the
+/// corresponding syntax tree.
+EXPERIMENTAL_FEATURE(BuiltinMacros)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3098,6 +3098,10 @@ static bool usesFeatureParserASTGen(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureBuiltinMacros(Decl *decl) {
+  return false;
+}
+
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {

lib/ASTGen/CMakeLists.txt

@@ -4,6 +4,7 @@ if (SWIFT_SWIFT_PARSER)
     Sources/ASTGen/Decls.swift
     Sources/ASTGen/Exprs.swift
     Sources/ASTGen/Literals.swift
+    Sources/ASTGen/Macros.swift
     Sources/ASTGen/Misc.swift
     Sources/ASTGen/SourceFile.swift
     Sources/ASTGen/Stmts.swift

lib/ASTGen/Package.swift

@@ -25,7 +25,8 @@ let package = Package(
             name: "swiftASTGen",
             dependencies: [
               .product(name: "SwiftSyntax", package: "swift-syntax"),
-              .product(name: "SwiftParser", package: "swift-syntax")
+              .product(name: "SwiftParser", package: "swift-syntax"),
+              .product(name: "_SwiftSyntaxMacros", package: "swift-syntax")
             ],
             path: ".",
             exclude: ["CMakeLists.txt"],

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -0,0 +1,75 @@
+import SwiftSyntax
+@_spi(Testing) import _SwiftSyntaxMacros
+
+extension SyntaxProtocol {
+  func token(at position: AbsolutePosition) -> TokenSyntax? {
+    // If the position isn't within this node at all, return early.
+    guard position >= self.position && position < self.endPosition else {
+      return nil
+    }
+
+    // If we are a token syntax, that's it!
+    if let token = Syntax(self).as(TokenSyntax.self) {
+      return token
+    }
+
+    // Otherwise, it must be one of our children.
+    return children(viewMode: .sourceAccurate).lazy.compactMap { child in
+      child.token(at: position)
+    }.first
+  }
+}
+
+@_cdecl("swift_ASTGen_printMacroResult")
+public func printMacroResult(
+  sourceFilePtr: UnsafeRawPointer,
+  sourceLocationPtr: UnsafePointer<UInt8>?
+) -> Int {
+  guard let sourceLocationPtr = sourceLocationPtr else {
+    print("NULL source location")
+    return -1
+  }
+
+  return sourceFilePtr.withMemoryRebound(
+    to: ExportedSourceFile.self, capacity: 1
+  ) { (sourceFile: UnsafePointer<ExportedSourceFile>) -> Int in
+    // Find the offset.
+    let buffer = sourceFile.pointee.buffer
+    let offset = sourceLocationPtr - buffer.baseAddress!
+    if offset < 0 || offset >= buffer.count {
+      print("source location isn't inside this buffer")
+      return -1
+    }
+
+    let sf = sourceFile.pointee.syntax
+    guard let token = sf.token(at: AbsolutePosition(utf8Offset: offset)) else {
+      print("couldn't find token at offset \(offset)")
+      return -1
+    }
+
+    guard let parentSyntax = token.parent,
+          parentSyntax.is(MacroExpansionExprSyntax.self) else {
+      print("not on a macro expansion node: \(token.recursiveDescription)")
+      return -1
+    }
+
+    let macroSystem = MacroSystem.exampleSystem
+    let converter = SourceLocationConverter(
+      file: sourceFile.pointee.fileName, tree: sf
+    )
+    let context = MacroEvaluationContext(
+      moduleName: sourceFile.pointee.moduleName,
+      sourceLocationConverter: converter
+    )
+
+    let evaluatedSyntax = parentSyntax.evaluateMacro(
+      with: macroSystem, context: context
+    ) { error in
+      /* TODO: Report errors */
+    }
+
+    print("Macro rewrite: \(parentSyntax.withoutTrivia()) --> \(evaluatedSyntax.withoutTrivia())")
+
+    return 0
+  }
+}

lib/Parse/ParseDecl.cpp

@@ -199,7 +199,8 @@ extern "C" void swift_ASTGen_buildTopLevelASTNodes(void *sourceFile,
 /// \endverbatim
 void Parser::parseTopLevel(SmallVectorImpl<Decl *> &decls) {
 #ifdef SWIFT_SWIFT_PARSER
-  if (Context.LangOpts.hasFeature(Feature::ParserASTGen) &&
+  if ((Context.LangOpts.hasFeature(Feature::BuiltinMacros) ||
+       Context.LangOpts.hasFeature(Feature::ParserASTGen)) &&
       !SourceMgr.hasCodeCompletionBuffer() &&
       SF.Kind != SourceFileKind::SIL) {
     StringRef contents =

lib/Sema/CMakeLists.txt

@@ -79,6 +79,14 @@ if(SWIFT_FORCE_OPTIMIZED_TYPECHECKER)
     target_compile_options(swiftSema PRIVATE -O3)
   endif()
 endif()
+
+if (SWIFT_SWIFT_PARSER)
+  target_compile_definitions(swiftSema
+    PRIVATE
+    SWIFT_SWIFT_PARSER
+  )
+endif()
+
 target_link_libraries(swiftSema PRIVATE
   swiftAST
   swiftParse

lib/Sema/CSApply.cpp

@@ -33,6 +33,7 @@
 #include "swift/AST/OperatorNameLookup.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/SourceFile.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/StringExtras.h"
@@ -53,6 +54,9 @@
 using namespace swift;
 using namespace constraints;
 
+extern "C" ptrdiff_t swift_ASTGen_printMacroResult(
+    void *sourceFile, const void *sourceLocation);
+
 bool Solution::hasFixedType(TypeVariableType *typeVar) const {
   auto knownBinding = typeBindings.find(typeVar);
   return knownBinding != typeBindings.end();
@@ -2969,6 +2973,18 @@ namespace {
     }
 
     Expr *visitMagicIdentifierLiteralExpr(MagicIdentifierLiteralExpr *expr) {
+#if SWIFT_SWIFT_PARSER
+      auto &ctx = cs.getASTContext();
+      if (ctx.LangOpts.hasFeature(Feature::BuiltinMacros)) {
+        if (auto sf = dc->getParentSourceFile()) {
+          if (auto astGenSF = sf->exportedSourceFile) {
+            swift_ASTGen_printMacroResult(
+                astGenSF, expr->getStartLoc().getOpaquePointerValue());
+          }
+        }
+      }
+#endif
+
       switch (expr->getKind()) {
 #define MAGIC_STRING_IDENTIFIER(NAME, STRING, SYNTAX_KIND) \
       case MagicIdentifierLiteralExpr::NAME: \

test/Macros/builtin_macros.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -enable-experimental-feature BuiltinMacros -typecheck %s -module-name MacrosTest 2>&1 | %FileCheck %s
+// REQUIRES: OS=macosx
+
+// CHECK: #function --> "MacrosTest"
+print(#function)
+
+func f(a: Int, b: Int) {
+  print(#function, #line, #column)
+  // CHECK-NEXT: #function --> "f(a:b:)"
+  // CHECK-NEXT: #line --> 8
+  // CHECK-NEXT: #column --> 27
+}