[@objc checking] Only 'Error' is representable in Objective-C (as 'NSError').

Don't allow types conforming to 'Error' or protocol compositions
involving 'Error' to be reflected in Objective-C. We still allow
bridging conversions, but they are not statically bridged. Fixes
SR-2249/rdar://problem/27658940.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -2750,6 +2750,8 @@ NOTE(not_objc_empty_protocol_composition,none,
      "'Any' is not considered '@objc'; use 'AnyObject' instead", ())
 NOTE(not_objc_protocol,none,
      "protocol %0 is not '@objc'", (Type))
+NOTE(not_objc_error_protocol_composition,none,
+     "protocol composition involving 'Error' is not '@objc'", ())
 NOTE(not_objc_empty_tuple,none,
       "empty tuple type cannot be represented in Objective-C", ())
 NOTE(not_objc_tuple,none,

lib/AST/Type.cpp

@@ -2189,33 +2189,8 @@ getForeignRepresentable(Type type, ForeignLanguage language,
   if (type->isTypeParameter() && language == ForeignLanguage::ObjectiveC)
     return { ForeignRepresentableKind::Object, nullptr };
 
-  // In Objective-C, existentials involving Error are bridged
-  // to NSError.
-  if (language == ForeignLanguage::ObjectiveC &&
-      type->isExistentialWithError()) {
-    return { ForeignRepresentableKind::BridgedError, nullptr };
-  }
-
-  /// Determine whether the given type is a type that is bridged to NSError
-  /// because it conforms to the Error protocol.
-  auto isBridgedErrorViaConformance = [dc](Type type) -> bool {
-    ASTContext &ctx = type->getASTContext();
-    auto errorProto = ctx.getProtocol(KnownProtocolKind::Error);
-    if (!errorProto) return false;
-
-    return dc->getParentModule()->lookupConformance(type, errorProto,
-                                                    ctx.getLazyResolver())
-             .hasValue();
-  };
-
   auto nominal = type->getAnyNominal();
-  if (!nominal) {
-    /// It might still be a bridged Error via conformance to Error.
-    if (isBridgedErrorViaConformance(type))
-      return { ForeignRepresentableKind::BridgedError, nullptr };
-
-    return failure();
-  }
+  if (!nominal) return failure();
 
   ASTContext &ctx = nominal->getASTContext();
 
@@ -2300,13 +2275,7 @@ getForeignRepresentable(Type type, ForeignLanguage language,
   // Determine whether this nominal type is known to be representable
   // in this foreign language.
   auto result = ctx.getForeignRepresentationInfo(nominal, language, dc);
-  if (result.getKind() == ForeignRepresentableKind::None) {
-    /// It might still be a bridged Error via conformance to Error.
-    if (isBridgedErrorViaConformance(type))
-      return { ForeignRepresentableKind::BridgedError, nullptr };
-
-    return failure();
-  }
+  if (result.getKind() == ForeignRepresentableKind::None) return failure();
 
   if (wasOptional && !result.isRepresentableAsOptional())
     return failure();

lib/PrintAsObjC/PrintAsObjC.cpp

@@ -1289,26 +1289,15 @@ class ObjCPrinter : private DeclVisitor<ObjCPrinter>,
     PCT = cast<ProtocolCompositionType>(canonicalComposition);
 
     // Dig out the protocols. If we see 'Error', record that we saw it.
-    bool hasError = false;
     SmallVector<ProtocolDecl *, 4> protos;
     for (auto protoTy : PCT->getProtocols()) {
       auto proto = protoTy->castTo<ProtocolType>()->getDecl();
-      if (proto->isSpecificProtocol(KnownProtocolKind::Error)) {
-        hasError = true;
-        continue;
-      }
-
       protos.push_back(proto);
     }
 
-    os << (isMetatype ? "Class"
-           : hasError ? "NSError"
-           : "id");
+    os << (isMetatype ? "Class" : "id");
     printProtocols(protos);
 
-    if (hasError && !isMetatype)
-      os << " *";
-
     printNullability(optionalKind);
   }
 
@@ -1823,10 +1812,9 @@ class ModuleWriter {
 
     ASTContext &ctx = M.getASTContext();
 
-    auto protos = ED->getAllProtocols();
+    SmallVector<ProtocolConformance *, 1> conformances;
     auto errorTypeProto = ctx.getProtocol(KnownProtocolKind::Error);
-    if (std::find(protos.begin(), protos.end(), errorTypeProto) !=
-        protos.end()) {
+    if (ED->lookupConformance(&M, errorTypeProto, conformances)) {
       bool hasDomainCase = std::any_of(ED->getAllElements().begin(),
                                        ED->getAllElements().end(),
                                        [](const EnumElementDecl *elem) {

lib/Sema/TypeCheckType.cpp

@@ -3237,13 +3237,25 @@ void TypeChecker::diagnoseTypeNotRepresentableInObjC(const DeclContext *DC,
       return;
     }
     // Find a protocol that is not @objc.
+    bool sawErrorProtocol = false;
     for (auto PD : Protocols) {
+      if (PD->isSpecificProtocol(KnownProtocolKind::Error)) {
+        sawErrorProtocol = true;
+        break;
+      }
+
       if (!PD->isObjC()) {
         diagnose(TypeRange.Start, diag::not_objc_protocol,
                  PD->getDeclaredType());
         return;
       }
     }
+
+    if (sawErrorProtocol) {
+      diagnose(TypeRange.Start, diag::not_objc_error_protocol_composition);
+      return;
+    }
+
     return;
   }
 

test/PrintAsObjC/error-delegate.swift

@@ -18,20 +18,12 @@
 
 import Foundation
 
-@objc protocol MySwiftProtocol { }
-
 // CHECK-LABEL: @interface Test : NSObject <ABCErrorProtocol>
 // CHECK-NEXT: - (void)didFail:(NSError * _Nonnull)error;
 // CHECK-NEXT: - (void)didFailOptional:(NSError * _Nullable)error;
-// CHECK-NEXT-FIXME: - (void)composition:(NSError<MySwiftProtocol> * _Nonnull)error;
-// CHECK-NEXT-FIXME: - (void)compositionOptional:(NSError<MySwiftProtocol> * _Nullable)error;
 // CHECK-NEXT: - (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
 // CHECK-NEXT: @end
 class Test : NSObject, ABCErrorProtocol {
   func didFail(_ error: Swift.Error) {}
   func didFailOptional(_ error: Swift.Error?) {}
-
-  // FIXME: SILGenc crashes on this.
-  //  func composition(_ error: MySwiftProtocol & Error) { }
-  //  func compositionOptional(_ error: (MySwiftProtocol & Error)?) { }
 }

test/attr/attr_objc.swift

@@ -11,6 +11,7 @@ struct PlainStruct {}
 enum PlainEnum {}
 protocol PlainProtocol {} // expected-note {{protocol 'PlainProtocol' declared here}}
 
+enum ErrorEnum : Error { }
 
 @objc class Class_ObjC1 {}
 
@@ -1932,6 +1933,20 @@ class ClassThrows1 {
   @objc init?(radians: Double) throws { } // expected-error{{a failable and throwing initializer cannot be marked @objc because 'nil' indicates failure to Objective-C}}
 
   @objc init!(string: String) throws { } // expected-error{{a failable and throwing initializer cannot be marked @objc because 'nil' indicates failure to Objective-C}}
+
+  @objc func fooWithErrorEnum1(x: ErrorEnum) {}
+  // expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
+  // expected-note@-2{{non-'@objc' enums cannot be represented in Objective-C}}
+
+  // CHECK: {{^}} func fooWithErrorEnum2(x: ErrorEnum)
+  func fooWithErrorEnum2(x: ErrorEnum) {}
+
+  @objc func fooWithErrorProtocolComposition1(x: Error & Protocol_ObjC1) { }
+  // expected-error@-1{{method cannot be marked @objc because the type of the parameter cannot be represented in Objective-C}}
+  // expected-note@-2{{protocol composition involving 'Error' is not '@objc'}}
+
+  // CHECK: {{^}} func fooWithErrorProtocolComposition2(x: Error & Protocol_ObjC1)
+  func fooWithErrorProtocolComposition2(x: Error & Protocol_ObjC1) { }
 }