[Macros] Check primary-file macro definitions more thoroughly.

Error if a macro is undefined, and warn if it refers to an external
macro definition that cannot be found.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -6777,6 +6777,8 @@ ERROR(external_macro_not_found,none,
       "external macro implementation type '%0.%1' could not be found for "
       "macro %2; the type must be public and provided via "
       "'-load-plugin-library'", (StringRef, StringRef, DeclName))
+ERROR(macro_must_be_defined,none,
+      "macro %0 requires a definition", (DeclName))
 NOTE(macro_note, none,
      "%1 (in macro %0)", (DeclName, StringRef))
 WARNING(macro_warning, none,

include/swift/AST/MacroDefinition.h

@@ -112,7 +112,7 @@ class MacroDefinition {
     return data.builtin;
   }
 
-  explicit operator bool() const { return kind != Kind::Invalid; }
+  operator Kind() const { return kind; }
 };
 
 }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2006,7 +2006,38 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (!MD->getMacroContexts())
       MD->diagnose(diag::macro_without_context, MD->getName());
 
-    (void)MD->getDefinition();
+    // Check the macro definition.
+    switch (auto macroDef = MD->getDefinition()) {
+    case MacroDefinition::Kind::Undefined:
+      MD->diagnose(diag::macro_must_be_defined, MD->getName());
+      break;
+
+    case MacroDefinition::Kind::Invalid:
+    case MacroDefinition::Kind::Builtin:
+      // Nothing else to check here.
+      break;
+
+    case MacroDefinition::Kind::External: {
+        // Retrieve the external definition of the macro.
+      auto external = macroDef.getExternalMacro();
+      ExternalMacroDefinitionRequest request{
+        &Ctx, external.moduleName, external.macroTypeName
+      };
+      auto externalDef = evaluateOrDefault(
+          Ctx.evaluator, request, ExternalMacroDefinition()
+                                           );
+      if (!externalDef.opaqueHandle) {
+        MD->diagnose(
+            diag::external_macro_not_found,
+            external.moduleName.str(),
+            external.macroTypeName.str(),
+            MD->getName()
+        ).limitBehavior(DiagnosticBehavior::Warning);
+      }
+
+      break;
+    }
+    }
   }
 
   void visitMacroExpansionDecl(MacroExpansionDecl *MED) {

lib/Sema/TypeCheckMacros.cpp

@@ -358,7 +358,7 @@ Expr *swift::expandMacroExpr(
   }
 
   case MacroDefinition::Kind::External: {
-    // Retrieve the extternal definition of the macro.
+    // Retrieve the external definition of the macro.
     auto external = macroDef.getExternalMacro();
     ExternalMacroDefinitionRequest request{
       &ctx, external.moduleName, external.macroTypeName

test/Macros/macro_availability_macosx.swift

@@ -5,6 +5,8 @@
 struct X { }
 
 @expression macro m1: X = #externalMacro(module: "A", type: "B") // expected-error{{'X' is only available in macOS 12.0 or newer}}
+// expected-warning@-1{{external macro implementation type 'A.B' could not be found for macro 'm1'}}
 
 @available(macOS 12.0, *)
 @expression macro m2: X = #externalMacro(module: "A", type: "B")
+// expected-warning@-1{{external macro implementation type 'A.B' could not be found for macro 'm2'}}

test/Macros/macros_diagnostics.swift

@@ -2,9 +2,12 @@
 
 @expression macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MacroDefinition", type: "StringifyMacro")
 // expected-note@-1 2{{'stringify' declared here}}
+// expected-warning@-2{{external macro implementation type}}
 @expression macro missingMacro1(_: Any) = MissingModule.MissingType // expected-note{{'missingMacro1' declared here}}
 // expected-warning@-1{{external macro definitions are now written using #externalMacro}}{{43-68=#externalMacro(module: "MissingModule", type: "MissingType")}}
+// expected-warning@-2{{external macro implementation type}}
 @expression macro missingMacro2(_: Any) = #externalMacro(module: "MissingModule", type: "MissingType")
+// expected-warning@-1{{external macro implementation type}}
 
 protocol P { }
 
@@ -16,36 +19,52 @@ internal struct X { } // expected-note{{type declared here}}
 
 @expression public macro createAnX: X = #externalMacro(module: "BuiltinMacros", type: "Blah")
 // expected-error@-1{{macro cannot be declared public because its result type uses an internal type}}
+// expected-warning@-2{{external macro implementation type}}
 
 @expression macro m1: Int = #externalMacro(module: "BuiltinMacros", type: "Blah")
+// expected-warning@-1{{external macro implementation type}}
 @expression macro m1: Float = #externalMacro(module: "BuiltinMacros", type: "Blah")
+// expected-warning@-1{{external macro implementation type}}
 
 @expression macro m2: Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-note{{'m2' previously declared here}}
+// expected-warning@-1{{external macro implementation type}}
 @expression macro m2: Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-error{{invalid redeclaration of 'm2'}}
+// expected-warning@-1{{external macro implementation type}}
 
 @expression macro m3(_: Int) -> Int = #externalMacro(module: "BuiltinMacros", type: "Blah")
+// expected-warning@-1{{external macro implementation type}}
 @expression macro m3(_: Int) -> Float = #externalMacro(module: "BuiltinMacros", type: "Blah")
+// expected-warning@-1{{external macro implementation type}}
 
 @expression macro m4(_: Int) -> Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-note{{'m4' previously declared here}}
+// expected-warning@-1{{external macro implementation type}}
 @expression macro m4(_: Int) -> Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-error{{invalid redeclaration of 'm4'}}
+// expected-warning@-1{{external macro implementation type}}
 
 struct ZZZ {
   macro m5: Int = #externalMacro(module: "BuiltinMacros", type: "Blah")
   // expected-error@-1{{macro 'm5' can only be declared at file scope}}
   // expected-error@-2{{macro 'm5' must declare its applicable contexts (e.g., '@expression')}}
+  // expected-warning@-3{{external macro implementation type}}
 }
 
 @expression macro multiArgMacro(_: Any, second: Any) = #externalMacro(module: "MissingModule", type: "MissingType")
 // expected-note@-1{{'multiArgMacro(_:second:)' declared here}}
+// expected-warning@-2{{external macro implementation type}}
 
 @expression macro overloaded1(_ p: P) = #externalMacro(module: "MissingModule", type: "MissingType")
+// expected-warning@-1{{external macro implementation type}}
+
 func overloaded1(_ p: Any) { }
 
 @expression macro notOverloaded1(_ p: P) = #externalMacro(module: "MissingModule", type: "MissingType") // expected-note{{'notOverloaded1' previously declared here}}
+// expected-warning@-1{{external macro implementation type}}
 @expression macro notOverloaded1(_ p: P) = #externalMacro(module: "MissingModule", type: "MissingOtherType") // expected-error{{invalid redeclaration of 'notOverloaded1'}}
+// expected-warning@-1{{external macro implementation type}}
 
 @expression macro intIdentity(value: Int, _: Float) -> Int = #externalMacro(module: "MissingModule", type: "MissingType")
 // expected-note@-1{{macro 'intIdentity(value:_:)' declared here}}
+// expected-warning@-2{{external macro implementation type}}
 
 func testDiags(a: Int, b: Int) {
   // FIXME: Bad diagnostic.
@@ -80,3 +99,6 @@ func shadow(a: Int, b: Int, stringify: Int) {
 func testMissing() {
   #missingMacro1("hello") // expected-error{{external macro implementation type 'MissingModule.MissingType' could not be found for macro 'missingMacro1'; the type must be public and provided via '-load-plugin-library'}}
 }
+
+@expression macro undefined() // expected-error{{macro 'undefined()' requires a definition}}
+

test/Macros/parsing.swift

@@ -3,10 +3,15 @@ protocol P { }
 protocol Q { associatedtype Assoc }
 
 @expression macro m1: Int = #externalMacro(module: "A", type: "M1")
+// expected-warning@-1{{external macro implementation type 'A.M1' could not be found for macro 'm1'; the type must be public and provided via '-load-plugin-library'}}
 @expression macro m2(_: Int) = #externalMacro(module: "A", type: "M2")
+// expected-warning@-1{{external macro implementation type 'A.M2' could not be found for macro 'm2'; the type must be public and provided via '-load-plugin-library'}}
 @expression macro m3(a b: Int) -> Int = #externalMacro(module: "A", type: "M3")
+// expected-warning@-1{{external macro implementation type 'A.M3' could not be found for macro 'm3(a:)'; the type must be public and provided via '-load-plugin-library'}}
 @expression macro m4<T: Q>: T = #externalMacro(module: "A", type: "M4") where T.Assoc: P
+// expected-warning@-1{{external macro implementation type 'A.M4' could not be found for macro 'm4'; the type must be public and provided via '-load-plugin-library'}}
 @expression macro m5<T: P>(_: T) = #externalMacro(module: "A", type: "M4")
+// expected-warning@-1{{external macro implementation type 'A.M4' could not be found for macro 'm5'; the type must be public and provided via '-load-plugin-library'}}
 
 @expression macro m6 = A // expected-error{{expected '(' for macro parameters or ':' for a value-like macro}}
 // expected-error@-1{{macro must itself be defined by a macro expansion such as '#externalMacro(...)'}}