[Macros] Type-check and use the result of macro-expanding an expression macro.

Once we have expanded an expression macro, parse and type-check the
result given a priori knowledge of the expanded type. Then, create an
implicit macro-expansion expression to capture the result of the
rewrite.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -6666,5 +6666,12 @@ ERROR(experimental_no_metadata_feature_can_only_be_used_when_enabled,
       " -enable-experimental-feature LayoutPrespecialization to swift to enable "
       " the usage of this language feature", ())
 
+
+//------------------------------------------------------------------------------
+// MARK: Macros
+//------------------------------------------------------------------------------
+ERROR(expected_macro_expansion_expr,PointsToFirstBadToken,
+      "expected macro expansion to produce an expression", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/AST/ASTDumper.cpp

@@ -2982,6 +2982,10 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
       OS << '\n';
       printArgumentList(E->getArgs());
     }
+    if (auto rewritten = E->getRewritten()) {
+      OS << '\n';
+      printRec(rewritten);
+    }
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 };

lib/Sema/CSApply.cpp

@@ -2977,8 +2977,14 @@ namespace {
         auto kind = MagicIdentifierLiteralExpr::getKindString(expr->getKind())
             .drop_front();
         auto expandedType = solution.simplifyType(solution.getType(expr));
-        if (auto newExpr = expandMacroExpr(dc, expr, kind, expandedType))
-          return newExpr;
+        if (auto newExpr = expandMacroExpr(dc, expr, kind, expandedType)) {
+          auto expansion = new (ctx) MacroExpansionExpr(
+              expr->getStartLoc(), expr, nullptr, /*isImplicit=*/true,
+              expandedType);
+          expansion->setRewritten(newExpr);
+          cs.cacheExprTypes(expansion);
+          return expansion;
+        }
 
         // Fall through to use old implementation.
       }

lib/Sema/TypeCheckMacros.cpp

@@ -15,11 +15,13 @@
 //===----------------------------------------------------------------------===//
 
 #include "TypeCheckMacros.h"
+#include "TypeChecker.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Parse/Lexer.h"
+#include "swift/Parse/Parser.h"
 
 using namespace swift;
 
@@ -74,7 +76,7 @@ Expr *swift::expandMacroExpr(
       std::tie(endLine, endColumn) =
           sourceMgr.getLineAndColumnInBuffer(endLoc, *bufferID);
 
-      out << sourceMgr.getIdentifierForBuffer(*bufferID) << ":"
+      out << " in " << sourceMgr.getIdentifierForBuffer(*bufferID) << ":"
           << startLine << ":" << startColumn
           << "-" << endLine << ":" << endColumn;
     }
@@ -86,13 +88,39 @@ Expr *swift::expandMacroExpr(
           StringRef(evaluatedSource, evaluatedSourceLength), bufferName);
   unsigned macroBufferID = sourceMgr.addNewSourceBuffer(std::move(macroBuffer));
 
-  // FIXME: Debug output.
-  llvm::outs() << "Macro rewrite: "
-    << "#" << macroName
-    << " --> " << sourceMgr.getEntireTextForBuffer(macroBufferID)
-    << "\n";
+  // Create a source file to hold the macro buffer.
+  // FIXME: Seems like we should record this somewhere?
+  auto macroSourceFile = new (ctx) SourceFile(
+      *dc->getParentModule(), SourceFileKind::Library, macroBufferID);
+
+  // Parse the expression.
+  Parser parser(macroBufferID, *macroSourceFile, &ctx.Diags, nullptr, nullptr);
+  parser.consumeTokenWithoutFeedingReceiver();
+  auto parsedResult = parser.parseExpr(diag::expected_macro_expansion_expr);
+  if (parsedResult.isParseError() || parsedResult.isNull()) {
+    // Tack on a note to say where we expanded the macro from?
+    return nullptr;
+  }
+
+  // Type-check the expanded expression.
+  // FIXME: Would like to pass through type checking options like "discarded"
+  // that are captured by TypeCheckExprOptions.
+  Expr *expandedExpr = parsedResult.get();
+  constraints::ContextualTypeInfo contextualType {
+    TypeLoc::withoutLoc(expandedType),
+    // FIXME: Add a contextual type purpose for macro expansion.
+    ContextualTypePurpose::CTP_CoerceOperand
+  };
+
+  Type realExpandedType = TypeChecker::typeCheckExpression(
+      expandedExpr, dc, contextualType);
+  if (!realExpandedType)
+    return nullptr;
 
-  return nullptr;
+  assert((expandedType->isEqual(realExpandedType) ||
+          realExpandedType->hasError()) &&
+         "Type checking changed the result type?");
+  return expandedExpr;
 }
 
 #endif // SWIFT_SWIFT_PARSER

test/Macros/builtin_macros.swift

@@ -1,12 +1,22 @@
-// RUN: %target-swift-frontend -enable-experimental-feature BuiltinMacros -typecheck %s -module-name MacrosTest 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -enable-experimental-feature BuiltinMacros -dump-ast %s -module-name MacrosTest 2>&1 | %FileCheck %s
 // REQUIRES: OS=macosx
 
-// CHECK: #function --> "MacrosTest"
+// CHECK: macro_expansion_expr implicit type='String'
+// CHECK-NEXT: magic_identifier_literal_expr{{.*}}kind=#function
+// CHECK-NEXT: string_literal_expr{{.*}}Macro expansion of #function in{{.*}}value="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
+  // CHECK: macro_expansion_expr implicit type='String'
+  // CHECK-NEXT: magic_identifier_literal_expr{{.*}}kind=#function
+  // CHECK-NEXT: string_literal_expr{{.*}}Macro expansion of #function in{{.*}}value="f(a:b:)"
+
+  // CHECK: macro_expansion_expr implicit type='Int'
+  // CHECK-NEXT: magic_identifier_literal_expr{{.*}}kind=#line
+  // CHECK-NEXT: integer_literal_expr{{.*}}Macro expansion of #line in{{.*}}value=10
+
+  // CHECK: macro_expansion_expr implicit type='Int'
+  // CHECK-NEXT: magic_identifier_literal_expr{{.*}}kind=#column
+  // CHECK-NEXT: integer_literal_expr{{.*}}Macro expansion of #column in{{.*}}value=27
 }