[SE-0112] Allow bridging from nominal and generic types to NSError.

Previously, a type that conformed to 'Error' could not be bridged to
NSError directly. Rather, one would have to go through the 'Error'
protocol, e.g.,

  myErrorValue as Error as NSError

rather than

  myErrorValue as NSError

Make the latter work.

Author: DougGregor

lib/AST/Type.cpp

@@ -1975,12 +1975,17 @@ bool TypeBase::isBridgeableObjectType() {
 }
 
 bool TypeBase::isPotentiallyBridgedValueType() {
+  // struct and enum types
   if (auto nominal = getAnyNominal()) {
     if (isa<StructDecl>(nominal) || isa<EnumDecl>(nominal))
       return true;
   }
 
-  return isExistentialWithError();
+  // Error existentials.
+  if (isExistentialWithError()) return true;
+
+  // Archetypes.
+  return is<ArchetypeType>();
 }
 
 /// Determine whether this is a representable Objective-C object type.
@@ -2150,9 +2155,33 @@ 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)
+  if (!nominal) {
+    /// It might still be a bridged Error via conformance to Error.
+    if (isBridgedErrorViaConformance(type))
+      return { ForeignRepresentableKind::BridgedError, nullptr };
+
     return failure();
+  }
 
   ASTContext &ctx = nominal->getASTContext();
 
@@ -2232,18 +2261,16 @@ getForeignRepresentable(Type type, ForeignLanguage language,
     }
   }
 
-  // In Objective-C, existentials involving Error are bridged
-  // to NSError.
-  if (language == ForeignLanguage::ObjectiveC &&
-      type->isExistentialWithError()) {
-    return { ForeignRepresentableKind::BridgedError, nullptr };
-  }
-
   // 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)
+  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 (wasOptional && !result.isRepresentableAsOptional())
     return failure();

stdlib/public/SDK/Foundation/NSError.swift

@@ -132,7 +132,7 @@ public extension Error where Self : CustomNSError {
 public extension Error {
   /// Retrieve the localized description for this error.
   var localizedDescription: String {
-    return (self as! NSError).localizedDescription
+    return (self as NSError).localizedDescription
   }
 }
 

test/Constraints/ErrorBridging.swift

@@ -41,3 +41,30 @@ let e1fix = ns1 as FooError // expected-error{{did you mean to use 'as!'}} {{17-
 
 let esub = ns1 as Error
 let esub2 = ns1 as? Error // expected-warning{{conditional cast from 'NSError' to 'Error' always succeeds}}
+
+// SR-1562 / rdar://problem/26370984
+enum MyError : Error {
+  case failed
+}
+
+func concrete1(myError: MyError) -> NSError {
+  return myError as NSError
+}
+
+func concrete2(myError: MyError) -> NSError {
+  return myError // expected-error{{cannot convert return expression of type 'MyError' to return type 'NSError'}}
+}
+
+func generic<T : Error>(error: T) -> NSError {
+  return error as NSError
+}
+
+extension Error {
+  var asNSError: NSError {
+    return self as NSError
+  }
+
+  var asNSError2: NSError {
+    return self // expected-error{{cannot convert return expression of type 'Self' to return type 'NSError'}}
+  }
+}

test/Constraints/casts.swift

@@ -30,7 +30,7 @@ var bad_d_is_b:Bool = D() is B // expected-warning{{always true}}
 func base_class_archetype_casts<T : B>(_ t: T) {
   var _ : B = t
   _ = B() as! T
-  var _ : T = B() // expected-error{{cannot convert value of type 'B' to specified type 'T'}}
+  var _ : T = B() // expected-error{{'B' is not convertible to 'T'; did you mean to use 'as!' to force downcast?}}
 
   let b = B()