[Sema] Validate names of @objc declarations with raw identifiers.

If a decl is exported to Objective-C (explicitly or implicitly), it
must be given an explicit name that is a valid Objective-C identifier.

Author: allevato

include/swift/AST/DiagnosticsSema.def

@@ -6417,6 +6417,14 @@ ERROR(objc_enum_case_multi,none,
 ERROR(objc_extension_not_class,none,
       "'@objc' can only be applied to an extension of a class", ())
 
+ERROR(objc_name_not_valid_identifier,none,
+      "'@objc' %0 name is not a valid Objective-C identifier",
+      (DescriptiveDeclKind))
+ERROR(objc_cannot_infer_name_raw_identifier,none,
+      "cannot infer '@objc' %0 name because the Swift name is not a valid "
+      "Objective-C identifier; specify the name in '@objc' explicitly",
+      (DescriptiveDeclKind))
+
 // If you change this, also change enum ObjCReason
 #define OBJC_ATTR_SELECT "select{marked @_cdecl|marked dynamic|marked @objc|marked @objcMembers|marked @IBOutlet|marked @IBAction|marked @IBSegueAction|marked @NSManaged|a member of an @objc protocol|implicitly @objc|an @objc override|an implementation of an @objc requirement|marked @IBInspectable|marked @GKInspectable|in an @objc extension of a class (without @nonobjc)|in an @objc @implementation extension of a class (without final or @nonobjc)|marked @objc by an access note}"
 

lib/Sema/TypeCheckDeclObjC.cpp

@@ -1635,6 +1635,56 @@ static std::optional<ObjCReason> shouldMarkAsObjC(const ValueDecl *VD,
   return currentlyObjC;
 }
 
+/// Emits a diagnostic for an invalid `@objc` name.
+static void diagnoseInvalidObjCName(ValueDecl *VD, ObjCAttr *attr) {
+  if (attr && !attr->getNameLocs().empty()) {
+    // Locate the diagnostic on the name itself if it was explicitly provided.
+    VD->getDiags().diagnose(attr->getNameLocs().front(),
+                            diag::objc_name_not_valid_identifier,
+                            VD->getDescriptiveKind());
+  } else {
+    switch (VD->getDescriptiveKind()) {
+    case DescriptiveDeclKind::Getter:
+    case DescriptiveDeclKind::Setter:
+      // If the name of the getter or setter isn't provided explicitly
+      // and the inferred name is invalid, then the property name must
+      // also be invalid and we'll diagnose that. Don't emit redundant
+      // diagnostics for the getter/setter.
+      break;
+    default:
+      VD->diagnose(diag::objc_cannot_infer_name_raw_identifier,
+                   VD->getDescriptiveKind());
+    }
+  }
+}
+
+// Returns true if all of the selector pieces are Obj-C compatible (i.e., no
+// raw identifiers with non-identifier characters).
+static bool isObjCSelectorValid(ObjCSelector selector) {
+  for (const auto &piece : selector.getSelectorPieces()) {
+    if (!piece.empty() && piece.mustAlwaysBeEscaped()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/// Checks whether the `@objc` name of a declaration is valid and emits a
+/// diagnostic if not.
+static void checkObjCNameValidity(ValueDecl *VD, ObjCAttr *attr) {
+  if (attr && attr->hasName()) {
+    // The name was explicitly provided by the attribute, so check that.
+    if (!isObjCSelectorValid(*attr->getName())) {
+      diagnoseInvalidObjCName(VD, attr);
+    }
+  } else {
+    // Check the original name of the declaration.
+    if (VD->getName().mustAlwaysBeEscaped()) {
+      diagnoseInvalidObjCName(VD, attr);
+    }
+  }
+}
+
 /// Determine whether the given type is a C integer type.
 static bool isCIntegerType(Type type) {
   auto nominal = type->getAnyNominal();
@@ -1677,7 +1727,8 @@ static bool isEnumObjC(EnumDecl *enumDecl) {
   // FIXME: Use shouldMarkAsObjC once it loses it's TypeChecker argument.
 
   // If there is no @objc attribute, it's not @objc.
-  if (!enumDecl->getAttrs().hasAttribute<ObjCAttr>())
+  auto attr = enumDecl->getAttrs().getAttribute<ObjCAttr>();
+  if (!attr)
     return false;
 
   Type rawType = enumDecl->getRawType();
@@ -1706,7 +1757,8 @@ static bool isEnumObjC(EnumDecl *enumDecl) {
   if (enumDecl->getAllElements().empty()) {
     enumDecl->diagnose(diag::empty_enum_raw_type);
   }
-  
+
+  checkObjCNameValidity(enumDecl, attr);
   return true;
 }
 
@@ -1727,14 +1779,18 @@ bool IsObjCRequest::evaluate(Evaluator &evaluator, ValueDecl *VD) const {
     // Members of classes can be @objc.
     isObjC = shouldMarkAsObjC(VD, isa<ConstructorDecl>(VD));
   }
-  else if (isa<ClassDecl>(VD)) {
+  else if (auto classDecl = dyn_cast<ClassDecl>(VD)) {
     // Classes can be @objc.
 
 
 
     // Protocols and enums can also be @objc, but this is covered by the
     // isObjC() check at the beginning.
     isObjC = shouldMarkAsObjC(VD, /*allowImplicit=*/false);
+    if (isObjC) {
+      checkObjCNameValidity(classDecl,
+                            classDecl->getAttrs().getAttribute<ObjCAttr>());
+    }
   } else if (auto enumDecl = dyn_cast<EnumDecl>(VD)) {
     // Enums can be @objc so long as they have a raw type that is representable
     // as an arithmetic type in C.
@@ -1744,13 +1800,17 @@ bool IsObjCRequest::evaluate(Evaluator &evaluator, ValueDecl *VD) const {
   } else if (auto enumElement = dyn_cast<EnumElementDecl>(VD)) {
     // Enum elements can be @objc so long as the containing enum is @objc.
     if (enumElement->getParentEnum()->isObjC()) {
-      if (auto attr = enumElement->getAttrs().getAttribute<ObjCAttr>())
+      auto attr = enumElement->getAttrs().getAttribute<ObjCAttr>();
+      checkObjCNameValidity(enumElement, attr);
+      if (attr)
         isObjC = objCReasonForObjCAttr(attr);
       else
         isObjC = ObjCReason::ElementOfObjCEnum;
     }
   } else if (auto proto = dyn_cast<ProtocolDecl>(VD)) {
-    if (auto attr = proto->getAttrs().getAttribute<ObjCAttr>()) {
+    auto attr = proto->getAttrs().getAttribute<ObjCAttr>();
+    if (attr) {
+      checkObjCNameValidity(proto, attr);
       isObjC = objCReasonForObjCAttr(attr);
 
       // If the protocol is @objc, it may only refine other @objc protocols and
@@ -1915,10 +1975,17 @@ static ObjCSelector inferObjCName(ValueDecl *decl) {
     }
   }
 
+  auto validateObjCSelector = [&](ObjCSelector selector) {
+    if (!isObjCSelectorValid(selector)) {
+      diagnoseInvalidObjCName(decl, attr);
+    }
+    return selector;
+  };
+
   // If the decl already has a name, do nothing; the protocol conformance
   // checker will handle any mismatches.
   if (attr && attr->hasName())
-    return *attr->getName();
+    return validateObjCSelector(*attr->getName());
 
   // When no override determined the Objective-C name, look for
   // requirements for which this declaration is a witness.
@@ -1965,7 +2032,7 @@ static ObjCSelector inferObjCName(ValueDecl *decl) {
     return *requirementObjCName;
   }
 
-  return *decl->getObjCRuntimeName(true);
+  return validateObjCSelector(*decl->getObjCRuntimeName(true));
 }
 
 /// Mark the given declaration as being Objective-C compatible (or

test/Sema/objc_raw_identifiers.swift

@@ -0,0 +1,52 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -verify -emit-module -o %t %s -module-name RawIdentifier -disable-objc-attr-requires-foundation-module
+
+// REQUIRES: objc_interop
+
+@objc(`Foo Bar`) public class FooBar {  // expected-error {{'@objc' class name is not a valid Objective-C identifier}}
+  @objc func `function with spaces`() {}  // expected-error {{cannot infer '@objc' instance method name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+
+  @objc(for) func forFunction1() {}
+  @objc(`while`) func whileFunction() {}
+  public func `not exported`() {}
+}
+
+@objc @objcMembers public class `Class with Spaces` {  // expected-error {{cannot infer '@objc' class name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+  public var `this is exported`: Int = 0  // expected-error {{cannot infer '@objc' property name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+
+  public var `another var`: Int {  // expected-error {{cannot infer '@objc' property name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+    get { 0 }
+    set {}
+  }
+
+  public var `yet another var`: Int {  // expected-error {{cannot infer '@objc' property name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+    @objc(`yet another getter`) get { 0 }  // expected-error {{'@objc' getter name is not a valid Objective-C identifier}}
+    @objc(`yet another setter`:) set {}  // expected-error {{'@objc' setter name is not a valid Objective-C identifier}}
+  }
+
+  public func `also exported`() {}  // expected-error {{cannot infer '@objc' instance method name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+
+  public init() {}
+
+  public init(`label with space`: Int) {}  // expected-error {{cannot infer '@objc' initializer name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+
+  public init(goodLabel `internal name`: Int) {}
+}
+
+@objc class NormalObjCClass {}
+
+class `Inherits from Objective-C Class`: NormalObjCClass {  // expected-error {{cannot infer '@objc' class name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+}
+
+@objc protocol `Some Protocol` {  // expected-error {{cannot infer '@objc' protocol name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+}
+
+@objc enum `Some Enum`: Int {  // expected-error {{cannot infer '@objc' enum name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+  case `some case A`  // expected-error {{cannot infer '@objc' enum case name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+  @objc(someCaseB) case `some case B`
+  @objc(`some case C`) case `some case C`  // expected-error {{'@objc' enum case name is not a valid Objective-C identifier}}
+}
+
+@objc enum EnumNameIsOK: Int {
+  case `raw identifier`  // expected-error {{cannot infer '@objc' enum case name because the Swift name is not a valid Objective-C identifier; specify the name in '@objc' explicitly}}
+}