Merge pull request #9009 from DougGregor/casts-and-errors-4.0

[4.0] Yet more targeted fixes

Author: DougGregor

lib/SILOptimizer/Utils/Local.cpp

@@ -1661,6 +1661,9 @@ optimizeBridgedSwiftToObjCCast(SILInstruction *Inst,
     if ((ConvTy == DestTy || DestTy.isExactSuperclassOf(ConvTy))) {
       CastedValue = SILValue(
           (ConvTy == DestTy) ? NewI : Builder.createUpcast(Loc, NewAI, DestTy));
+    } else if (ConvTy.isExactSuperclassOf(DestTy)) {
+      CastedValue = SILValue(
+          Builder.createUnconditionalCheckedCast(Loc, NewAI, DestTy));
     } else if (ConvTy.getSwiftRValueType() ==
                    getNSBridgedClassOfCFClass(M.getSwiftModule(),
                                               DestTy.getSwiftRValueType()) ||
@@ -1673,8 +1676,7 @@ optimizeBridgedSwiftToObjCCast(SILInstruction *Inst,
     } else {
       llvm_unreachable(
           "Destination should have the same type, be bridgeable CF "
-          "type or be a superclass "
-          "of the source operand");
+          "type or be a superclass/subclass of the source operand");
     }
     NewI = Builder.createStore(Loc, CastedValue, Dest,
                                StoreOwnershipQualifier::Unqualified);

lib/Sema/TypeCheckError.cpp

@@ -665,18 +665,17 @@ class ApplyClassifier {
   Classification classifyRethrowsArgument(Expr *arg, Type paramType) {
     arg = arg->getValueProvidingExpr();
 
-    // If the parameter was a tuple, try to look through the various
-    // tuple operations.
-    if (auto paramTupleType = paramType->getAs<TupleType>()) {
+    // If the parameter was structurally a tuple, try to look through the
+    // various tuple operations.
+    if (auto paramTupleType = dyn_cast<TupleType>(paramType.getPointer())) {
       if (auto tuple = dyn_cast<TupleExpr>(arg)) {
         return classifyTupleRethrowsArgument(tuple, paramTupleType);
       } else if (auto shuffle = dyn_cast<TupleShuffleExpr>(arg)) {
         return classifyShuffleRethrowsArgument(shuffle, paramTupleType);
       }
 
       int scalarElt = paramTupleType->getElementForScalarInit();
-      if (scalarElt < 0 ||
-          !paramTupleType->getElementType(scalarElt)->isEqual(arg->getType())) {
+      if (scalarElt < 0) {
         // Otherwise, we're passing an opaque tuple expression, and we
         // should treat it as contributing to 'rethrows' if the original
         // parameter type included a throwing function type.

test/SILOptimizer/bridged_casts_folding.swift

@@ -900,4 +900,16 @@ public func testCondCastSwiftToCFSetInt() -> CFSet? {
   return setOpt
 }
 
+public class NSObjectSubclass : NSObject { }
 
+var anyHashable: AnyHashable = 0
+
+// CHECK-LABEL: _T021bridged_casts_folding29testUncondCastSwiftToSubclassAA08NSObjectI0CyF
+// CHECK: [[GLOBAL:%[0-9]+]] = global_addr @_T021bridged_casts_folding11anyHashables03AnyE0Vv
+// CHECK: function_ref @_T0s11AnyHashableV10FoundationE19_bridgeToObjectiveCSo8NSObjectCyF
+// CHECK-NEXT: apply
+// CHECK-NEXT: unconditional_checked_cast {{%.*}} : $NSObject to $NSObjectSubclass
+@inline(never)
+public func testUncondCastSwiftToSubclass() -> NSObjectSubclass {
+  return anyHashable as! NSObjectSubclass
+}

test/decl/func/rethrows.swift

@@ -480,6 +480,11 @@ func throwWhileGettingFoo() throws -> Foo.Type { return Foo.self }
 // <rdar://problem/31794932> [Source compatibility] Call to sort(by):) can throw, but is not marked with 'try'
 func doRethrow(fn: (Int, Int) throws -> Int) rethrows { }
 
+struct DoRethrowGeneric<T> {
+  func method(fn: (T, T) throws -> T) rethrows { }
+}
+
 func testDoRethrow() {
   doRethrow(fn:) { (a, b) in return a }
+  DoRethrowGeneric<Int>().method(fn:) { (a, b) in return a }
 }