Parse expression macro expansion buffers as expressions

This started out as a crash, where an expression macro could not be
defined in terms of one of the builtin macros (e.g., `#line`), because
we were expecting a macro expansion expression but didn't get one.
Easy fix.

However, this uncovered a second bug, which is that we couldn't handle
an expression macro expansino to `#line`. This is because we were
parsing the macro expansion buffer as "top level items", which treats
`#line` at the start of a line as a deprecated alias of
`#sourceLocation`. Switch over to parsing a single expression in these
contexts, and fix up an issue where `#isolation` didn't even have that
expression.

Fixes rdar://139372780.

Author: DougGregor

include/swift/AST/DiagnosticsParse.def

@@ -2095,6 +2095,8 @@ ERROR(unexpected_attribute_expansion,PointsToFirstBadToken,
 ERROR(unexpected_member_expansion,PointsToFirstBadToken,
       "unexpected token '%0' in expanded member list",
       (StringRef))
+ERROR(extra_tokens_after_expression,PointsToFirstBadToken,
+      "extra tokens after expression in macro expansion", ())
 
 ERROR(parser_round_trip_error,none,
       "source file did not round-trip through the new Swift parser", ())

lib/Parse/ParseRequests.cpp

@@ -180,10 +180,27 @@ SourceFileParsingResult ParseSourceFileRequest::evaluate(Evaluator &evaluator,
       break;
 
     case GeneratedSourceInfo::ExpressionMacroExpansion:
+    case GeneratedSourceInfo::DefaultArgument: {
+      // Prime the lexer.
+      if (parser.Tok.is(tok::NUM_TOKENS))
+        parser.consumeTokenWithoutFeedingReceiver();
+
+      ParserResult<Expr> resultExpr = parser.parseExpr(diag::expected_expr);
+      if (auto expr = resultExpr.getPtrOrNull())
+        items.push_back(expr);
+
+      if (!parser.Tok.is(tok::eof)) {
+        parser.diagnose(parser.Tok, diag::extra_tokens_after_expression);
+        while (!parser.Tok.is(tok::eof))
+          parser.consumeToken();
+      }
+
+      break;
+    }
+
     case GeneratedSourceInfo::PreambleMacroExpansion:
     case GeneratedSourceInfo::ReplacedFunctionBody:
-    case GeneratedSourceInfo::PrettyPrinted:
-    case GeneratedSourceInfo::DefaultArgument: {
+    case GeneratedSourceInfo::PrettyPrinted:{
       parser.parseTopLevelItems(items);
       break;
     }

lib/Sema/TypeCheckMacros.cpp

@@ -199,6 +199,14 @@ MacroDefinition MacroDefinitionRequest::evaluate(
   if (!typeCheckedType)
     return MacroDefinition::forInvalid();
 
+  // If the expanded macro was one of the the magic literal expressions
+  // (like #file), there's nothing to expand.
+  if (auto magicLiteral =
+          dyn_cast<MagicIdentifierLiteralExpr>(definition)) {
+    StringRef expansionText = externalMacroName.unbridged();
+    return MacroDefinition::forExpanded(ctx, expansionText, { }, { });
+  }
+
   // Dig out the macro that was expanded.
   auto expansion = cast<MacroExpansionExpr>(definition);
   auto expandedMacro =
@@ -1105,9 +1113,10 @@ evaluateFreestandingMacro(FreestandingMacroExpansion *expansion,
       return nullptr;
 
     case BuiltinMacroKind::IsolationMacro:
-      // Create a buffer full of scratch space; this will be populated
-      // much later.
-      std::string scratchSpace(128, ' ');
+      // Create a buffer with "nil" plus a bunch of scratch space. This
+      // will be populated much later.
+      std::string scratchSpace = "nil";
+      scratchSpace.append(125, ' ');
       evaluatedSource = llvm::MemoryBuffer::getMemBufferCopy(
           scratchSpace,
           adjustMacroExpansionBufferName(*discriminator));

test/Macros/macro_expand_other.swift

@@ -36,4 +36,9 @@ func testFreestandingExpansionOfOther() {
   #endif
 }
 
+@freestanding(expression)
+macro myLineMacro() -> Int = #line
+
+var thisLine = #myLineMacro
+
 testFreestandingExpansionOfOther()