[Macros] Don't parse the macro expansion buffer twice.

Each macro expansion buffer was getting parsed twice: once by
ParseSourceFileRequest (which is used by unqualified name lookup) and
once to parse the expression when type-checking the expanded macro.
This meant that the same code had two ASTs. Hilarity ensures.

Stop directly invoking the parser on macro-expanded code. Instead, go
through ParseSourceFileRequest *as is always the right way*, and dig
out the expression we want.

Author: DougGregor

include/swift/Basic/SourceManager.h

@@ -23,6 +23,8 @@
 
 namespace swift {
 
+class DeclContext;
+
 /// Augments a buffer that was created specifically to hold generated source
 /// code with the reasons for it being generated.
 class GeneratedSourceInfo {
@@ -53,8 +55,11 @@ class GeneratedSourceInfo {
   /// generated source, but it will never be from a different buffer.
   SourceRange generatedSourceRange;
 
-  /// The opaque pointer for an ASTNode.
+  /// The opaque pointer for an ASTNode for which this buffer was generated.
   void *astNode;
+
+  /// The declaration context in which this buffer logically resides.
+  DeclContext *declContext;
 };
 
 /// This class manages and owns source buffers.

lib/IDETool/CompileInstance.cpp

@@ -196,7 +196,8 @@ void retypeCheckFunctionBody(AbstractFunctionDecl *func,
         *func->getParentSourceFile()->getBufferID(),
         func->getOriginalBodySourceRange(),
         newRange,
-        func
+        func,
+        nullptr
       }
   );
   func->setBodyToBeReparsed(newRange);

lib/IDETool/IDEInspectionInstance.cpp

@@ -349,7 +349,8 @@ bool IDEInspectionInstance::performCachedOperationIfPossible(
           *AFD->getParentSourceFile()->getBufferID(),
           AFD->getOriginalBodySourceRange(),
           newBodyRange,
-          AFD
+          AFD,
+          nullptr
         }
     );
 

lib/Parse/ParseRequests.cpp

@@ -164,6 +164,14 @@ SourceFileParsingResult ParseSourceFileRequest::evaluate(Evaluator &evaluator,
   Parser parser(*bufferID, *SF, /*SIL*/ nullptr, state);
   PrettyStackTraceParser StackTrace(parser);
 
+  // If the buffer is generated source information that is conceptually within
+  // a particular declaration context, use that for the parser's declaration
+  // context instead of the source file.
+  if (auto generatedInfo = ctx.SourceMgr.getGeneratedSourceInfo(*bufferID)) {
+    if (generatedInfo->declContext)
+      parser.CurDeclContext = generatedInfo->declContext;
+  }
+
   SmallVector<ASTNode, 128> items;
   parser.parseTopLevelItems(items);
 

lib/Sema/TypeCheckMacros.cpp

@@ -29,7 +29,6 @@
 #include "swift/Basic/StringExtras.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Parse/Lexer.h"
-#include "swift/Parse/Parser.h"
 #include "swift/Subsystems.h"
 
 using namespace swift;
@@ -129,12 +128,8 @@ Expr *swift::expandMacroExpr(
   ASTContext &ctx = dc->getASTContext();
   SourceManager &sourceMgr = ctx.SourceMgr;
 
-  // FIXME: Introduce a more robust way to ensure that we can get the "exported"
-  // source file for a given context. If it's within a macro expansion, it
-  // may not have a C++ SourceFile, but will have a Syntax tree.
-  //
-  // FIXME^2: And find a better name for "exportedSourceFile".
-  auto sourceFile = dc->getParentSourceFile();
+  auto moduleDecl = dc->getParentModule();
+  auto sourceFile = moduleDecl->getSourceFileContainingLocation(expr->getLoc());
   if (!sourceFile)
     return nullptr;
 
@@ -225,7 +220,8 @@ Expr *swift::expandMacroExpr(
     *sourceFile->getBufferID(),
     expr->getSourceRange(),
     SourceRange(macroBufferRange.getStart(), macroBufferRange.getEnd()),
-    ASTNode(expr).getOpaqueValue()
+    ASTNode(expr).getOpaqueValue(),
+    dc
   };
   sourceMgr.setGeneratedSourceInfo(macroBufferID, sourceInfo);
   free((void*)evaluatedSource.data());
@@ -236,24 +232,22 @@ Expr *swift::expandMacroExpr(
       *dc->getParentModule(), SourceFileKind::MacroExpansion, macroBufferID,
       /*parsingOpts=*/{}, /*isPrimary=*/false);
 
-  // Parse the expression.
-  Parser parser(macroBufferID, *macroSourceFile, &ctx.Diags, nullptr, nullptr);
-  parser.consumeTokenWithoutFeedingReceiver();
-
-  // Set up a "local context" for parsing, so that we have a source of
-  // closure and local-variable discriminators.
-  parser.CurDeclContext = dc;
+  // Retrieve the parsed expression from the list of top-level items.
+  auto topLevelItems = macroSourceFile->getTopLevelItems();
+  Expr *expandedExpr = nullptr;
+  if (topLevelItems.size() == 1) {
+    expandedExpr = topLevelItems.front().dyn_cast<Expr *>();
+  }
 
-  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?
+  if (!expandedExpr) {
+    ctx.Diags.diagnose(
+        macroBufferRange.getStart(), diag::expected_macro_expansion_expr);
     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.

test/Macros/macro_expand.swift

@@ -49,6 +49,10 @@ struct Outer {
   var value: Int = 0
   func test() {
     _ = #stringify(1 + value)
+
+    _ = #stringify({ x in
+      x + 1
+    })
   }
 }