[Macros] Ensure that we check the macro definition in the primary file.

Otherwise, we won't diagnose issues with a macro until the point of use.

Author: DougGregor

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -39,6 +39,7 @@
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/MacroDefinition.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/PrettyStackTrace.h"
@@ -2004,6 +2005,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       MD->diagnose(diag::macro_in_nested, MD->getName());
     if (!MD->getMacroContexts())
       MD->diagnose(diag::macro_without_context, MD->getName());
+
+    (void)MD->getDefinition();
   }
 
   void visitMacroExpansionDecl(MacroExpansionDecl *MED) {

test/Macros/macro_availability_macosx.swift

@@ -4,7 +4,7 @@
 @available(macOS 12.0, *)
 struct X { }
 
-@expression macro m1: X = A.B // expected-error{{'X' is only available in macOS 12.0 or newer}}
+@expression macro m1: X = #externalMacro(module: "A", type: "B") // expected-error{{'X' is only available in macOS 12.0 or newer}}
 
 @available(macOS 12.0, *)
-@expression macro m2: X = A.B
+@expression macro m2: X = #externalMacro(module: "A", type: "B")

test/Macros/macro_expand.swift

@@ -18,7 +18,7 @@
 
 @expression macro customFileID: String = #externalMacro(module: "MacroDefinition", type: "FileIDMacro")
 @expression macro stringify<T>(_ value: T) -> (T, String) = #externalMacro(module: "MacroDefinition", type: "StringifyMacro")
-@expression macro fileID<T: _ExpressibleByStringLiteral>: T = #externalMacro(module: "MacroDefinition", type: "FileIDMacro")
+@expression macro fileID<T: ExpressibleByStringLiteral>: T = #externalMacro(module: "MacroDefinition", type: "FileIDMacro")
 @expression macro recurse(_: Bool) = #externalMacro(module: "MacroDefinition", type: "RecursiveMacro")
 
 func testFileID(a: Int, b: Int) {

test/Macros/macros_diagnostics.swift

@@ -4,46 +4,47 @@
 // expected-note@-1 2{{'stringify' declared here}}
 @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")}}
-@expression macro missingMacro2(_: Any) = MissingModule.MissingType
+@expression macro missingMacro2(_: Any) = #externalMacro(module: "MissingModule", type: "MissingType")
 
 protocol P { }
 
-@expression macro tryToHide<T: P>(_: P) -> some P = BuiltinMacros.Blah
+@expression macro tryToHide<T: P>(_: T) -> some P = #externalMacro(module: "BuiltinMacros", type: "Blah")
 // expected-error@-1{{some' types are only permitted in properties, subscripts, and functions}}
+// expected-error@-2{{generic parameter 'T' could not be inferred}}
 
 internal struct X { } // expected-note{{type declared here}}
 
-@expression public macro createAnX: X = BuiltinMacros.Blah
+@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}}
 
-@expression macro m1: Int = A.B
-@expression macro m1: Float = A.B
+@expression macro m1: Int = #externalMacro(module: "BuiltinMacros", type: "Blah")
+@expression macro m1: Float = #externalMacro(module: "BuiltinMacros", type: "Blah")
 
-@expression macro m2: Int = A.B // expected-note{{'m2' previously declared here}}
-@expression macro m2: Int = A.B // expected-error{{invalid redeclaration of 'm2'}}
+@expression macro m2: Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-note{{'m2' previously declared here}}
+@expression macro m2: Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-error{{invalid redeclaration of 'm2'}}
 
-@expression macro m3(_: Int) -> Int = A.B
-@expression macro m3(_: Int) -> Float = A.B
+@expression macro m3(_: Int) -> Int = #externalMacro(module: "BuiltinMacros", type: "Blah")
+@expression macro m3(_: Int) -> Float = #externalMacro(module: "BuiltinMacros", type: "Blah")
 
-@expression macro m4(_: Int) -> Int = A.B // expected-note{{'m4' previously declared here}}
-@expression macro m4(_: Int) -> Int = A.B // expected-error{{invalid redeclaration of 'm4'}}
+@expression macro m4(_: Int) -> Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-note{{'m4' previously declared here}}
+@expression macro m4(_: Int) -> Int = #externalMacro(module: "BuiltinMacros", type: "Blah") // expected-error{{invalid redeclaration of 'm4'}}
 
 struct ZZZ {
-  macro m5: Int = A.B
+  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')}}
 }
 
-@expression macro multiArgMacro(_: Any, second: Any) = MissingModule.MissingType
+@expression macro multiArgMacro(_: Any, second: Any) = #externalMacro(module: "MissingModule", type: "MissingType")
 // expected-note@-1{{'multiArgMacro(_:second:)' declared here}}
 
-@expression macro overloaded1(_ p: P) = MissingModule.MissingType
+@expression macro overloaded1(_ p: P) = #externalMacro(module: "MissingModule", type: "MissingType")
 func overloaded1(_ p: Any) { }
 
-@expression macro notOverloaded1(_ p: P) = MissingModule.MissingType // expected-note{{'notOverloaded1' previously declared here}}
-@expression macro notOverloaded1(_ p: P) = MissingModule.MissingOtherType // expected-error{{invalid redeclaration of 'notOverloaded1'}}
+@expression macro notOverloaded1(_ p: P) = #externalMacro(module: "MissingModule", type: "MissingType") // expected-note{{'notOverloaded1' previously declared here}}
+@expression macro notOverloaded1(_ p: P) = #externalMacro(module: "MissingModule", type: "MissingOtherType") // expected-error{{invalid redeclaration of 'notOverloaded1'}}
 
-@expression macro intIdentity(value: Int, _: Float) -> Int = MissingModule.MissingType
+@expression macro intIdentity(value: Int, _: Float) -> Int = #externalMacro(module: "MissingModule", type: "MissingType")
 // expected-note@-1{{macro 'intIdentity(value:_:)' declared here}}
 
 func testDiags(a: Int, b: Int) {

test/Macros/parsing.swift

@@ -9,3 +9,4 @@ protocol Q { associatedtype Assoc }
 @expression macro m5<T: P>(_: T) = #externalMacro(module: "A", type: "M4")
 
 @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(...)'}}