macros_diagnostics.swift

// REQUIRES: swift_swift_parser, asserts
// REQUIRES: swift_feature_CodeItemMacros

// RUN: %target-typecheck-verify-swift -swift-version 5 -enable-experimental-feature CodeItemMacros -module-name MacrosTest

@expression macro stringify<T>(_ value:T)->(T,String)= #externalMacro(module:"MacroDefinition", type:"StringifyMacro")
// expected-note@-1 3{{'stringify' declared here}}
// expected-warning@-2{{external macro implementation type}}
// expected-warning@-3{{'@expression' has been removed in favor of '@freestanding(expression)'}}{{1-12=@freestanding(expression)}}
@freestanding(expression) macro missingMacro1(_:Any)=MissingModule.MissingType // expected-note{{'missingMacro1' declared here}}
// expected-warning@-1{{external macro definitions are now written using #externalMacro}}
// expected-warning@-2{{external macro implementation type}}
// expected-note@-3{{use '#externalMacro'}}{{57-82=#externalMacro(module: "MissingModule", type: "MissingType")}}
@freestanding(expression) macro missingMacro2(_:Any)= #externalMacro(module:"MissingModule", type:"MissingType")
// expected-warning@-1{{external macro implementation type}}

protocolP{}

@freestanding(expression) macro tryToHide<T:P>(_:T)->someP= #externalMacro(module:"BuiltinMacros", type:"Blah")
// expected-error@-1{{some' types are only permitted in properties, subscripts, and functions}}
// expected-warning@-2{{external macro implementation type}}

internalstructX{} // expected-note{{type declared here}}

@freestanding(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}}

@freestanding(expression) macro m1()->Int= #externalMacro(module:"BuiltinMacros", type:"Blah")
// expected-warning@-1{{external macro implementation type}}
@freestanding(expression) macro m1()->Float= #externalMacro(module:"BuiltinMacros", type:"Blah")
// expected-warning@-1{{external macro implementation type}}

@freestanding(expression) macro m2()->Int= #externalMacro(module:"BuiltinMacros", type:"Blah") // expected-note{{'m2()' previously declared here}}
// expected-warning@-1{{external macro implementation type}}
@freestanding(expression) macro m2()->Int= #externalMacro(module:"BuiltinMacros", type:"Blah") // expected-error{{invalid redeclaration of 'm2()'}}
// expected-warning@-1{{external macro implementation type}}

@freestanding(expression) macro m3(_:Int)->Int= #externalMacro(module:"BuiltinMacros", type:"Blah")
// expected-warning@-1{{external macro implementation type}}
@freestanding(expression) macro m3(_:Int)->Float= #externalMacro(module:"BuiltinMacros", type:"Blah")
// expected-warning@-1{{external macro implementation type}}

@freestanding(expression) macro m4(_:Int)->Int= #externalMacro(module:"BuiltinMacros", type:"Blah") // expected-note{{'m4' previously declared here}}
// expected-warning@-1{{external macro implementation type}}
@freestanding(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()= #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 roles}}
 // expected-warning@-3{{external macro implementation type}}
}

@freestanding(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}}

@freestanding(expression) macro overloaded1(_ p:P)= #externalMacro(module:"MissingModule", type:"MissingType")
// expected-warning@-1{{external macro implementation type}}

func overloaded1(_ p:Any){}

@freestanding(expression) macro notOverloaded1(_ p:P)= #externalMacro(module:"MissingModule", type:"MissingType") // expected-note{{'notOverloaded1' previously declared here}}
// expected-warning@-1{{external macro implementation type}}
@freestanding(expression) macro notOverloaded1(_ p:P)= #externalMacro(module:"MissingModule", type:"MissingOtherType") // expected-error{{invalid redeclaration of 'notOverloaded1'}}
// expected-warning@-1{{external macro implementation type}}

// Overloading based on generic constraint.
publicprotocolResultBuilder{
}

@freestanding(expression)public macro ApplyBuilder<R:ResultBuilder>(resultBuilder:R.Type, to closure:()->Void)->(()->String)= #externalMacro(module:"MacroExamplesPlugin", type:"ResultBuilderMacro")
// expected-warning@-1{{external macro implementation type}}
@freestanding(expression)public macro ApplyBuilder<R>(resultBuilder:R.Type, to closure:()->Void)->(()->String)= #externalMacro(module:"MacroExamplesPlugin", type:"ResultBuilderMacro2")
// expected-warning@-1{{external macro implementation type}}

@freestanding(expression) macro intIdentity(value:Int, _:Float)->Int= #externalMacro(module:"MissingModule", type:"MissingType")
// expected-note@-1{{'intIdentity(value:_:)' declared here}}
// expected-warning@-2{{external macro implementation type}}

// FIXME: #63376
// @freestanding(expression) macro usesAssocType<T: BinaryInteger>: T.Magnitude = #externalMacro(module: "MissingModule", type: "MissingType")

@freestanding(declaration) macro justProducesDiags(_ x:String) // okay
// expected-error @-1 {{macro 'justProducesDiags' requires a definition}}
@freestanding(declaration, names: arbitrary)
macro unaryDeclMacro(_ x:String)
// expected-error @-1 {{macro 'unaryDeclMacro' requires a definition}}
@freestanding(declaration, names: arbitrary)
macro unaryDeclMacro(_ x:String, blah:Bool)
// expected-error @-1 {{macro 'unaryDeclMacro(_:blah:)' requires a definition}}
@freestanding(declaration, names: arbitrary)
macro genericDeclMacro<T:Numeric, U:Numeric>(_ x:T, _ y:U)
// expected-error @-1 {{macro 'genericDeclMacro' requires a definition}}
// expected-note @-2 {{where 'U' = 'String'}}

func testDiags(a:Int, b:Int){
lets= #stringify<Int,Int>(a + b) // expected-error{{generic type 'stringify' specialized with too many type parameters (got 2, but expected 1)}}

 _ = #stringify()
 // expected-error@-1{{missing argument for parameter #1 in macro expansion}}
 _ = #stringify(label: a + b)
 // expected-error@-1{{extraneous argument label 'label:' in macro expansion}}

 _ = #multiArgMacro() // expected-error{{missing arguments for parameters #1, 'second' in macro expansion}}
 _ = #multiArgMacro(1,2) // expected-error{{missing argument label 'second:' in macro expansion}}{{25-25=second: }}

 _ = #multiArgMacro(1, second:2){} // expected-error{{extra trailing closure passed in macro expansion}}
 _ = #multiArgMacro(1, second:2,3) // expected-error{{extra argument in macro expansion}}
 _ = #multiArgMacro(1, second:2, third:3) // expected-error{{extra argument 'third' in macro expansion}}

 _ =stringify(a + b)
 // expected-error@-1{{expansion of macro 'stringify' requires leading '#'}}{{7-7=#}}

 _ = #intIdentity // expected-error{{missing arguments for parameters 'value', #2 in macro expansion}}{{19-19=(value: <#Int#>, <#Float#>)}}

overloaded1(a) // okay, calls the function
 #overloaded1(a) // expected-error{{argument type 'Int' does not conform to expected type 'P'}}

// #unaryDeclMacro("abc") // okay, declaration macro where both exprs and decls are allowed
// _ = #unaryDeclMacro("abc") // xpected-error {{no macro named 'unaryDeclMacro'}}
// (#unaryDeclMacro("abc"), 3) // xpected-error {{no macro named 'unaryDeclMacro'}}

struct Foo {
 #unaryDeclMacro("abc", blah:false) // okay
 #unaryDeclMacro("abc", blah:false, oh:2) // expected-error {{extra argument 'oh' in macro expansion}}
 #genericDeclMacro(2,4.0) // okay
 #genericDeclMacro(2,"not a number") // expected-error {{macro 'genericDeclMacro' requires that 'String' conform to 'Numeric'}}
}
}

func shadow(a:Int, b:Int, stringify:Int){
 _ = #stringify(a + b)
 // expected-error@-1{{external macro implementation type 'MacroDefinition.StringifyMacro' could not be found for macro 'stringify'; plugin for module 'MacroDefinition' not found}}
}

func testMissing(){
 #missingMacro1("hello") // expected-error{{external macro implementation type 'MissingModule.MissingType' could not be found for macro 'missingMacro1'; plugin for module 'MissingModule' not found}}
}

@freestanding(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}}
}

@freestanding(expression)
public macro macroWithDefaults(_:Int=17)= #externalMacro(module:"A", type:"B")
// expected-warning@-1{{external macro implementation type 'A.B' could not be found for macro 'macroWithDefaults'; plugin for module 'A' not found}}
// expected-note@-2{{'macroWithDefaults' declared here}}

func callMacroWithDefaults(){
 _ = #macroWithDefaults()
 // expected-error@-1 {{external macro implementation type 'A.B' could not be found for macro 'macroWithDefaults'; plugin for module 'A' not found}}
}

// Make sure we don't allow macros to prevent type folding.
@attached(member)
public macro MacroOrType()= #externalMacro(module:"A", type:"MacroOrType")
// expected-warning@-1{{external macro implementation type}}

@freestanding(codeItem, names:named(foo))
public macro badCodeItemMacro()= #externalMacro(module:"A", type:"B")
// expected-error@-2{{'codeItem' macros are not allowed to introduce names}}
// expected-warning@-2{{external macro implementation type 'A.B' could not be found for macro 'badCodeItemMacro()'; plugin for module 'A' not found}}

structMacroOrType{
typealiasNested=Int
}

func test(){
let _:[MacroOrType.Nested]=[]
 _ =[MacroOrType.Nested]()
}

// Make sure we have the right declaration context for type-checking the result
// types of macros. At one point, we would reject the following macro.
protocolMyProto{
}
structMyStruct<T:MyProto>{
}

@freestanding(expression) macro myMacro<T :MyProto>(_ value:MyStruct<T>)->MyStruct<T>= #externalMacro(module:"A", type:"B")
// expected-warning@-1{{external macro implementation type}}

#undefinedMacro { definitelyNotDefined }
// expected-error@-1{{cannot find 'definitelyNotDefined' in scope}}
// expected-error@-2{{no macro named 'undefinedMacro'}}

@freestanding(declaration) macro genericUnary<T>(_:T)= #externalMacro(module:"A", type:"B")
// expected-warning@-1{{external macro implementation type}}
// expected-note@-2{{'genericUnary' declared here}}

struct SomeType {
 #genericUnary<Equatable>(0asHashable)
 // expected-warning@-1{{use of protocol 'Equatable' as a type must be written 'any Equatable'}}
 // expected-warning@-2{{use of protocol 'Hashable' as a type must be written 'any Hashable'}}
 // expected-error@-3{{external macro implementation type}}
}



@freestanding(declaration) macro nonExpressionReturnsInt<T>(_:T)->Int= #externalMacro(module:"A", type:"B")
// expected-warning@-1{{external macro implementation type}}
// expected-error@-2{{only a freestanding expression macro can produce a result of type 'Int'}}
// expected-note@-3{{make this macro a freestanding expression macro}}{{1-1=@freestanding(expression)\n}}
// expected-note@-4{{remove the result type if the macro does not produce a value}}{{67-74=}}

@freestanding(declaration) macro nonExpressionReturnsVoid<T>(_:T)->Void= #externalMacro(module:"A", type:"B")
// expected-warning@-1{{external macro implementation type}}
// expected-error@-2{{only a freestanding expression macro can produce a result of type 'Void'}}
// expected-note@-3{{make this macro a freestanding expression macro}}{{1-1=@freestanding(expression)\n}}
// expected-note@-4{{remove the result type if the macro does not produce a value}}{{68-76=}}


@freestanding(expression)
@freestanding(declaration)
macro multipleFreestandingRoles<T>(_:T)->Void= #externalMacro(module:"A", type:"B")
// expected-warning@-1{{external macro implementation type}}
// expected-error@-2{{macro can only have a single freestanding role}}

@_documentation(visibility: private)
@attached(peer)
macro Foo()= #externalMacro(module:"ThisMacroModuleDoesNotExist", type:"ThisMacroTypeDoesNotExist")
// expected-warning@-1{{external macro implementation type}}


@available(SwiftStdlib 5.1,*)
func someGlobalNext(
 isolation actor: isolated (anyActor)?= #isolated // expected-error{{no macro named 'isolated'}}
)asyncthrows{
fatalError()
}