Merge pull request #84489 from xymus/c-identifier-only

Parser: Reject `@c` attributes using the string format

test/attr/attr_cdecl_official.swift

@@ -12,6 +12,10 @@
 // expected-error @-1 {{expected ')' in 'c' attribute}}
 // expected-error @-2 {{expected declaration}}
 
+@c("old string syntax") func stringSyntax() {}
+// expected-error @-1 {{expected C identifier in 'c' attribute}}
+// expected-error @-2 {{expected declaration}}
+
 @c() func emptyParen() {}
 // expected-error @-1 {{expected C identifier in 'c' attribute}}
 // expected-error @-2 {{expected declaration}}
@@ -26,83 +30,83 @@
 
 @c func defaultName() {}
 
-@c("noBody")
+@c(noBody)
 func noBody(x: Int) -> Int // expected-error{{expected '{' in body of function}}
 
-@c("property") // expected-error{{'@c' attribute cannot be applied to this declaration}}
+@c(property) // expected-error{{'@c' attribute cannot be applied to this declaration}}
 var property: Int
 
 var computed: Int {
-  @c("get_computed") get { return 0 }
-  @c("set_computed") set { return }
+  @c(get_computed) get { return 0 }
+  @c(set_computed) set { return }
 }
 
-@c("inout")
+@c(`inout`)
 func noBody(x: inout Int) { } // expected-error{{global function cannot be marked '@c' because inout parameters cannot be represented in C}}
 
 struct SwiftStruct { var x, y: Int }
 enum SwiftEnum { case A, B }
 
 #if os(Windows) && (arch(x86_64) || arch(arm64))
-@c("CEnum") enum CEnum: Int32 { case A, B }
+@c(CEnum) enum CEnum: Int32 { case A, B }
 #else
-@c("CEnum") enum CEnum: Int { case A, B }
+@c(CEnum) enum CEnum: Int { case A, B }
 #endif
 
 @c enum CEnumDefaultName: CInt { case A, B }
 
-@c("CEnumNoRawType") enum CEnumNoRawType { case A, B }
+@c(CEnumNoRawType) enum CEnumNoRawType { case A, B }
 // expected-error @-1 {{'@c' enum must declare an integer raw type}}
 
-@c("CEnumStringRawType") enum CEnumStringRawType: String { case A, B }
+@c(CEnumStringRawType) enum CEnumStringRawType: String { case A, B }
 // expected-error @-1 {{'@c' enum raw type 'String' is not an integer type}}
 
-@c("swiftStruct")
+@c(swiftStruct)
 func swiftStruct(x: SwiftStruct) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{Swift structs cannot be represented in C}}
 
-@c("swiftEnum")
+@c(swiftEnum)
 func swiftEnum(x: SwiftEnum) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{Swift enums not marked '@c' cannot be represented in C}}
 
-@c("cEnum")
+@c(cEnum)
 func cEnum(x: CEnum) {}
 
-@c("CDeclAndObjC") // expected-error {{cannot apply both '@c' and '@objc' to enum}}
+@c(CDeclAndObjC) // expected-error {{cannot apply both '@c' and '@objc' to enum}}
 @objc
 enum CDeclAndObjC: CInt { case A, B }
 
-@c("TwoCDecls") // expected-note {{attribute already specified here}}
+@c(TwoCDecls) // expected-note {{attribute already specified here}}
 @_cdecl("TwoCDecls") // expected-error {{duplicate attribute}}
 func TwoCDecls() {}
 
 class Foo {
-  @c("Foo_foo") // expected-error{{@c can only be applied to global functions}}
+  @c(Foo_foo) // expected-error{{@c can only be applied to global functions}}
   func foo(x: Int) -> Int { return x }
 
-  @c("Foo_foo_2") // expected-error{{@c can only be applied to global functions}}
+  @c(Foo_foo_2) // expected-error{{@c can only be applied to global functions}}
   static func foo(x: Int) -> Int { return x }
 
-  @c("Foo_init") // expected-error{{'@c' attribute cannot be applied to this declaration}}
+  @c(Foo_init) // expected-error{{'@c' attribute cannot be applied to this declaration}}
   init() {}
 
-  @c("Foo_deinit") // expected-error{{'@c' attribute cannot be applied to this declaration}}
+  @c(Foo_deinit) // expected-error{{'@c' attribute cannot be applied to this declaration}}
   deinit {}
 }
 
-@c("throwing") // expected-error{{raising errors from @c functions is not supported}}
+@c(throwing) // expected-error{{raising errors from @c functions is not supported}}
 func throwing() throws { }
 
-@c("acceptedPointers")
+@c(acceptedPointers)
 func acceptedPointers(_ x: UnsafeMutablePointer<Int>,
                         y: UnsafePointer<Int>,
                         z: UnsafeMutableRawPointer,
                         w: UnsafeRawPointer,
                         u: OpaquePointer) {}
 
-@c("rejectedPointers")
+@c(rejectedPointers)
 func rejectedPointers( // expected-error 6 {{global function cannot be marked '@c' because the type of the parameter}}
     x: UnsafePointer<String>, // expected-note {{Swift structs cannot be represented in C}}
     y: CVaListPointer, // expected-note {{Swift structs cannot be represented in C}}
@@ -111,90 +115,90 @@ func rejectedPointers( // expected-error 6 {{global function cannot be marked '@
     v: UnsafeRawBufferPointer, // expected-note {{Swift structs cannot be represented in C}}
     t: UnsafeMutableRawBufferPointer) {} // expected-note {{Swift structs cannot be represented in C}}
 
-@c("genericParam")
+@c(genericParam)
 func genericParam<I>(i: I) {}
 // expected-error @-1 {{global function cannot be marked '@c' because it has generic parameters}}
 
-@c("variadic")
+@c(variadic)
 func variadic(_: Int...) {}
 // expected-error @-1 {{global function cannot be marked '@c' because it has a variadic parameter}}
 
-@c("tupleParamEmpty")
+@c(tupleParamEmpty)
 func tupleParamEmpty(a: ()) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{empty tuple type cannot be represented in C}}
 
-@c("tupleParam")
+@c(tupleParam)
 func tupleParam(a: (Int, Float)) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{tuples cannot be represented in C}}
 
-@c("emptyTupleReturn")
+@c(emptyTupleReturn)
 func emptyTupleReturn() -> () {}
 
-@c("tupleReturn")
+@c(tupleReturn)
 func tupleReturn() -> (Int, Float) { (1, 2.0) }
 // expected-error @-1 {{global function cannot be marked '@c' because its result type cannot be represented in C}}
 // expected-note @-2 {{tuples cannot be represented in C}}
 
-@c("funcAcceptsThrowingFunc")
+@c(funcAcceptsThrowingFunc)
 func funcAcceptsThrowingFunc(fn: (String) throws -> Int) { }
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{throwing function types cannot be represented in C}}
 
-@c("funcAcceptsThrowingFuncReturn")
+@c(funcAcceptsThrowingFuncReturn)
 func funcAcceptsThrowingFuncReturn() -> (String) throws -> Int { fatalError() }
 // expected-error @-1 {{global function cannot be marked '@c' because its result type cannot be represented in C}}
 // expected-note @-2 {{throwing function types cannot be represented in C}}
 
-@c("bar")
+@c(bar)
 func bar(f: (SwiftEnum) -> SwiftStruct) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{function types cannot be represented in C unless their parameters and returns can be}}
 
-@c("bas")
+@c(bas)
 func bas(f: (SwiftEnum) -> ()) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{function types cannot be represented in C unless their parameters and returns can be}}
 
-@c("zim")
+@c(zim)
 func zim(f: () -> SwiftStruct) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{function types cannot be represented in C unless their parameters and returns can be}}
 
-@c("zang")
+@c(zang)
 func zang(f: (SwiftEnum, SwiftStruct) -> ()) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{function types cannot be represented in C unless their parameters and returns can be}}
 
-@c("zang_zang")
+@c(zang_zang)
   func zangZang(f: (Int...) -> ()) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{function types cannot be represented in C unless their parameters and returns can be}}
 
-@c("array")
+@c(array)
 func array(i: [Int]) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{Swift structs cannot be represented in C}}
 
 class SwiftClass {}
-@c("swiftClass")
+@c(swiftClass)
 func swiftClass(p: SwiftClass) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{classes cannot be represented in C}}
 
 protocol SwiftProtocol {}
-@c("swiftProtocol")
+@c(swiftProtocol)
 func swiftProtocol(p: SwiftProtocol) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{protocols cannot be represented in C}}
 
-@c("swiftErrorProtocol")
+@c(swiftErrorProtocol)
 func swiftErrorProtocol(e: Error) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{protocols cannot be represented in C}}
 
-@c("anyParam")
+@c(anyParam)
 func anyParam(e:Any) {}
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{protocols cannot be represented in C}}

test/attr/attr_cdecl_official_async.swift

@@ -8,10 +8,10 @@
 @_cdecl("async") // expected-error{{@_cdecl global function cannot be asynchronous}}
 func asynchronous() async { }
 
-@c("async2") // expected-error{{@c global function cannot be asynchronous}}
+@c(async2) // expected-error{{@c global function cannot be asynchronous}}
 func asynchronous2() async { }
 
-@c("asyncParam")
+@c(asyncParam)
 func asynchronousParam(fn: (String) async -> Int) { }
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{'async' function types cannot be represented in C}}

test/attr/attr_cdecl_official_rejected.swift

@@ -4,9 +4,9 @@
 
 // REQUIRES: swift_feature_CDecl
 
-@c("cdecl_foo") func foo() { } // expected-error {{'@c' requires '-enable-experimental-feature CDecl'}}
+@c(cdecl_foo) func foo() { } // expected-error {{'@c' requires '-enable-experimental-feature CDecl'}}
 
 var computed: Int {
-  @c("get_computed") get { return 0 } // expected-error {{'@c' requires '-enable-experimental-feature CDecl'}}
-  @c("set_computed") set { } // expected-error {{'@c' requires '-enable-experimental-feature CDecl'}}
+  @c(get_computed) get { return 0 } // expected-error {{'@c' requires '-enable-experimental-feature CDecl'}}
+  @c(set_computed) set { } // expected-error {{'@c' requires '-enable-experimental-feature CDecl'}}
 }

test/attr/attr_cdecl_official_with_objc.swift

@@ -9,11 +9,11 @@ import Foundation
 @objc
 class ObjCClass: NSObject { }
 
-@c("objcClassReturn") func objcClassReturn() -> ObjCClass { fatalError() }
+@c(objcClassReturn) func objcClassReturn() -> ObjCClass { fatalError() }
 // expected-error @-1 {{global function cannot be marked '@c' because its result type cannot be represented in C}}
 // expected-note @-2 {{classes cannot be represented in C}}
 
-@c("objcClassParams") func objcClassParams(a: ObjCClass, b: ObjCClass) { }
+@c(objcClassParams) func objcClassParams(a: ObjCClass, b: ObjCClass) { }
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter 1 cannot be represented in C}}
 // expected-error @-2 {{global function cannot be marked '@c' because the type of the parameter 2 cannot be represented in C}}
 // expected-note @-3 2 {{classes cannot be represented in C}}
@@ -21,18 +21,18 @@ class ObjCClass: NSObject { }
 @objc
 protocol ObjCProtocol {}
 
-@c("objcProtocol") func objcProtocol(a: ObjCProtocol) { }
+@c(objcProtocol) func objcProtocol(a: ObjCProtocol) { }
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{protocols cannot be represented in C}}
 
 @objc
 enum ObjCEnum: Int { case A, B }
-@c("objcEnumUseInCDecl") func objcEnumUseInCDecl(a: ObjCEnum) { }
+@c(objcEnumUseInCDecl) func objcEnumUseInCDecl(a: ObjCEnum) { }
 // expected-error @-1 {{global function cannot be marked '@c' because the type of the parameter cannot be represented in C}}
 // expected-note @-2 {{Swift enums not marked '@c' cannot be represented in C}}
 
 /// Objective-C accepts @c enums.
-@c("CEnum")
+@c(CEnum)
 enum CEnum: Int { case A, B }
 @_cdecl("cdeclEnumUseInObjc") func cdeclEnumUseInObjc(a: CEnum) { }