[Macros] Disable macro expansion within the definition of macros.

... and once we do that, ensure that `#externalMacro` can only be
expanded as the definition of another macro.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -6779,6 +6779,8 @@ ERROR(external_macro_not_found,none,
       "'-load-plugin-library'", (StringRef, StringRef, DeclName))
 ERROR(macro_must_be_defined,none,
       "macro %0 requires a definition", (DeclName))
+ERROR(external_macro_outside_macro_definition,none,
+      "macro 'externalMacro' can only be used to define another macro", ())
 NOTE(macro_note, none,
      "%1 (in macro %0)", (DeclName, StringRef))
 WARNING(macro_warning, none,

include/swift/Sema/ConstraintSystem.h

@@ -1794,6 +1794,9 @@ enum class ConstraintSystemFlags {
 
   /// When set, ignore async/sync mismatches
   IgnoreAsyncSyncMismatch = 0x80,
+
+  /// Disable macro expansions.
+  DisableMacroExpansions = 0x100,
 };
 
 /// Options that affect the constraint system as a whole.

lib/Sema/CSApply.cpp

@@ -5397,11 +5397,13 @@ namespace {
       ConcreteDeclRef macroRef = resolveConcreteDeclRef(macro, locator);
       E->setMacroRef(macroRef);
 
-      if (auto newExpr = expandMacroExpr(dc, E, macroRef, expandedType)) {
-        E->setRewritten(newExpr);
-        cs.cacheExprTypes(E);
+      if (!cs.Options.contains(ConstraintSystemFlags::DisableMacroExpansions)) {
+        if (auto newExpr = expandMacroExpr(dc, E, macroRef, expandedType)) {
+          E->setRewritten(newExpr);
+        }
       }
 
+      cs.cacheExprTypes(E);
       return E;
     }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -422,6 +422,9 @@ TypeChecker::typeCheckTarget(SolutionApplicationTarget &target,
   if (options.contains(TypeCheckExprFlags::LeaveClosureBodyUnchecked))
     csOptions |= ConstraintSystemFlags::LeaveClosureBodyUnchecked;
 
+  if (options.contains(TypeCheckExprFlags::DisableMacroExpansions))
+    csOptions |= ConstraintSystemFlags::DisableMacroExpansions;
+
   ConstraintSystem cs(dc, csOptions);
 
   if (auto *expr = target.getAsExpr()) {

lib/Sema/TypeCheckMacros.cpp

@@ -234,7 +234,8 @@ MacroDefinition MacroDefinitionRequest::evaluate(
 
   PrettyStackTraceDecl debugStack("type checking macro definition", macro);
   Type typeCheckedType = TypeChecker::typeCheckExpression(
-      definition, macro, contextualType);
+      definition, macro, contextualType,
+      TypeCheckExprFlags::DisableMacroExpansions);
   if (!typeCheckedType)
     return MacroDefinition::forInvalid();
 
@@ -352,7 +353,8 @@ Expr *swift::expandMacroExpr(
   case MacroDefinition::Kind::Builtin: {
     switch (macroDef.getBuiltinKind()) {
     case BuiltinMacroKind::ExternalMacro:
-      // FIXME: Error here.
+        ctx.Diags.diagnose(
+            expr->getLoc(), diag::external_macro_outside_macro_definition);
       return nullptr;
     }
   }

lib/Sema/TypeChecker.h

@@ -138,6 +138,9 @@ enum class TypeCheckExprFlags {
 
   /// Don't type check expressions for correct availability.
   DisableExprAvailabilityChecking = 0x08,
+
+  /// Don't expansino macros.
+  DisableMacroExpansions = 0x10,
 };
 
 using TypeCheckExprOptions = OptionSet<TypeCheckExprFlags>;

test/Macros/macros_diagnostics.swift

@@ -102,3 +102,7 @@ func testMissing() {
 
 @expression macro undefined() // expected-error{{macro 'undefined()' requires a definition}}
 
+func testExternalMacroOutOfPlace() {
+  let _: Int = #externalMacro(module: "A", type: "B")
+  // expected-error@-1{{macro 'externalMacro' can only be used to define another macro}}
+}