[clang] ns_error_domain attribute also supports CFString typed variables

[arphaman]

Summary

The change in a5b8757506b07e3091fe243b6c1e004220d3cba3 locked down the ns_error_domain attribute to NSString only, however we actually support CFString as well.

[aaron.ballman]

LGTM

clang/include/clang/Basic/AttrDocs.td

 }
 
 def NSErrorDomainDocs : Documentation {
   let Category = DocCatDecl;
   let Content = [{
 In Cocoa frameworks in Objective-C, one can group related error codes in enums
 and categorize these enums with error domains.
 
-The ``ns_error_domain`` attribute indicates a global ``NSString`` constant
-representing the error domain that an error code belongs to. For pointer
-uniqueness and code size this is a constant symbol, not a literal.
+The ``ns_error_domain`` attribute indicates a global ``NSString`` or
+``CFString`` constant representing the error domain that an error code belongs
+to. For pointer uniqueness and code size this is a constant symbol, not a
+literal.
 
 The domain and error code need to be used together. The ``ns_error_domain``
 attribute links error codes to their domain at the source level.
 
 This metadata is useful for documentation purposes, for static analysis, and for
 improving interoperability between Objective-C and Swift. It is not used for
 code generation in Objective-C.
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_nsconsumed_attribute_mismatch : Error<
   "overriding method has mismatched ns_consumed attribute on its"
   " parameter">;
 def err_nsreturns_retained_attribute_mismatch : Error<
   "overriding method has mismatched ns_returns_%select{not_retained|retained}0"
   " attributes">;
 def err_nserrordomain_invalid_decl : Error<
   "domain argument %select{|%1 }0does not refer to global constant">;
 def err_nserrordomain_wrong_type : Error<
-  "domain argument %0 does not point to an NSString constant">;
+  "domain argument %0 does not point to an NSString or CFString constant">;
 
 def warn_nsconsumed_attribute_mismatch : Warning<
   err_nsconsumed_attribute_mismatch.Text>, InGroup<NSConsumedMismatch>;
 def warn_nsreturns_retained_attribute_mismatch : Warning<
   err_nsreturns_retained_attribute_mismatch.Text>, InGroup<NSReturnsMismatch>;
 
 def note_getter_unavailable : Note<
   "or because setter is declared here, but no getter method %0 is found">;

clang/lib/Sema/SemaDeclAttr.cpp

static void handleNSErrorDomain(Sema &S, Decl *D, const ParsedAttr &AL) {
   }
 
   auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
   if (!VD) {
     S.Diag(Loc, diag::err_nserrordomain_invalid_decl) << 1 << DRE->getDecl();
     return;
   }
 
-  if (!isNSStringType(VD->getType(), S.Context)) {
+  if (!isNSStringType(VD->getType(), S.Context) &&
+      !isCFStringType(VD->getType(), S.Context)) {
     S.Diag(Loc, diag::err_nserrordomain_wrong_type) << VD;
     return;
   }
 
   D->addAttr(::new (S.Context) NSErrorDomainAttr(S.Context, AL, VD));
 }
 
 static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {

clang/test/Sema/ns_error_enum.m

 
 typedef NSString *const NsErrorDomain;
 extern NsErrorDomain MyTypedefErrorDomain;
 typedef NS_ERROR_ENUM(unsigned char, MyTypedefErrorEnum, MyTypedefErrorDomain) {
   MyTypedefErrFirst,
   MyTypedefErrSecond,
 };
 
+typedef const struct __CFString * CFStringRef;
+
+extern CFStringRef const MyCFErrorDomain;
+typedef NS_ERROR_ENUM(unsigned char, MyCFErrorEnum, MyCFErrorDomain) {
+  MyCFErrFirst,
+  MyCFErrSecond,
+};
+
+typedef CFStringRef CFErrorDomain;
+extern CFErrorDomain const MyCFTypedefErrorDomain;
+typedef NS_ERROR_ENUM(unsigned char, MyCFTypedefErrorEnum, MyCFTypedefErrorDomain) {
+  MyCFTypedefErrFirst,
+  MyCFTypedefErrSecond,
+};
+
 extern char *const WrongErrorDomainType;
 enum __attribute__((ns_error_domain(WrongErrorDomainType))) MyWrongErrorDomainType { MyWrongErrorDomain };
-// expected-error@-1{{domain argument 'WrongErrorDomainType' does not point to an NSString constant}}
+// expected-error@-1{{domain argument 'WrongErrorDomainType' does not point to an NSString or CFString constant}}
 
 struct __attribute__((ns_error_domain(MyErrorDomain))) MyStructWithErrorDomain {};
 // expected-error@-1{{'ns_error_domain' attribute only applies to enums}}
 
 int __attribute__((ns_error_domain(MyErrorDomain))) NotTagDecl;
   // expected-error@-1{{'ns_error_domain' attribute only applies to enums}}
 
 enum __attribute__((ns_error_domain())) NoArg { NoArgError };