[silgen] Fix a bug where when reabstracting T:P -> P we wrapped a +0 value in an init_existential_ref.

Found via the ownership verifier running on IRGen/outlined_copy_addr.swift.

We treat initialization of an existential as a +1 operation, so there is the
possibility that we would have double destroyed a value. In fixing this I
followed what manageOpaqueValue did on the first code path, since it is handling
this case correctly (and using the SGFContext to do so to boot!).

To ensure this is tested, I enabled ownership verification on the test and since
it seems to be exposing a SILGen code path that we aren't testing currently,
converted it into a SILGen test.

Author: gottesmm

lib/SILGen/SILGenPoly.cpp

@@ -241,7 +241,11 @@ static ManagedValue emitTransformExistential(SILGenFunction &SGF,
                    [&](SGFContext C) -> ManagedValue {
                      if (openedArchetype)
                        return SGF.manageOpaqueValue(state, loc, C);
-                     return input;
+                     if (input.isPlusOne(SGF))
+                       return input;
+                     if (C.isGuaranteedPlusZeroOk())
+                       return input;
+                     return input.copyUnmanaged(SGF, loc);
                    });
 
   return input;

test/IRGen/outlined_copy_addr.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -emit-ir  -module-name outcopyaddr -primary-file %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -enable-sil-ownership -module-name outcopyaddr -primary-file %s | %FileCheck %s
 
 public protocol BaseProt {
 }

test/SILGen/reabstract.swift

@@ -112,3 +112,23 @@ func testSharedOwnedOpaque(_ s: C, o: C) {
   let box = Box(t: evenLessFun)
   box.t(s, o)
 }
+
+// Make sure that when we generate the reabstraction thunk from Klass -> P, we
+// pass off the value at +1.
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] [ossa] @$s10reabstract1P_pIegg_xIegg_AaBRzlTR : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@guaranteed τ_0_0, @guaranteed @callee_guaranteed (@guaranteed P) -> ()) -> () {
+// CHECK: bb0([[ARG:%.*]] : @guaranteed $τ_0_0,
+// CHECK:   [[ARG_COPY:%.*]] = copy_value [[ARG]]
+// CHECK:   [[EXISTENTIAL:%.*]] = init_existential_ref [[ARG_COPY]]
+// CHECK:   [[BORROWED_EXISTENTIAL:%.*]] = begin_borrow [[EXISTENTIAL]]
+// CHECK:   apply {{%.*}}([[BORROWED_EXISTENTIAL]])
+// CHECK:   end_borrow [[BORROWED_EXISTENTIAL]]
+// CHECK:   destroy_value [[EXISTENTIAL]]
+// CHECK: } // end sil function '$s10reabstract1P_pIegg_xIegg_AaBRzlTR'
+protocol P : class {}
+class Klass : P { }
+extension P { static func crash(setup: ((Self) -> ())?) {} }
+func checkInitExistentialThunk() -> P? {
+  let cls : P.Type = Klass.self
+  cls.crash(setup: { (arg:  P) -> () in  })
+  return nil
+}