SILGen: Properly copy a nonunique OpaqueValueExpr when it's needed at +1.

emitManagedRetain only retains things; use ManagedValue::copyUnmanaged instead.

Swift SVN r27185

Author: jckarter

lib/SILGen/SILGenExpr.cpp

@@ -3166,8 +3166,10 @@ RValue RValueEmitter::visitOpenExistentialExpr(OpenExistentialExpr *E,
     break;
   case ExistentialRepresentation::Boxed:
     assert(existentialValue.getValue().getType().isObject());
+    // NB: Don't forward the cleanup, because consuming a boxed value won't
+    // consume the box reference.
     archetypeValue = SGF.B.createOpenExistentialBox(
-                       E, existentialValue.forward(SGF),
+                       E, existentialValue.getValue(),
                        SGF.getLoweredType(opaqueValueType));
     // The boxed value can't be assumed to be uniquely referenced.
     isUnique = false;
@@ -3202,9 +3204,10 @@ RValue RValueEmitter::visitOpaqueValueExpr(OpaqueValueExpr *E, SGFContext C) {
     return RValue(SGF, E, SGF.emitManagedRValueWithCleanup(entry.value));
   }
 
-  // Retain the value.
+  // Otherwise, copy the value.
   entry.hasBeenConsumed = true;
-  return RValue(SGF, E, SGF.emitManagedRetain(E, entry.value));
+  return RValue(SGF, E,
+                ManagedValue::forUnmanaged(entry.value).copyUnmanaged(SGF, E));
 }
 
 ProtocolDecl *SILGenFunction::getPointerProtocol() {

test/SILGen/boxed_existentials.swift

@@ -55,3 +55,27 @@ func test_property(x: _ErrorType) -> String {
 // CHECK:         [[RESULT:%.*]] = apply [[METHOD]]<[[VALUE_TYPE]]>([[VALUE]])
 // CHECK:         strong_release %0
 // CHECK:         return [[RESULT]]
+
+extension _ErrorType {
+  final func extensionMethod() { }
+}
+
+// CHECK-LABEL: sil hidden @_TF18boxed_existentials21test_extension_methodFPSs10_ErrorType_T_
+func test_extension_method(error: _ErrorType) {
+  // -- TODO: could avoid an r/r here by guaranteeing the box, even if
+  //          the value inside is still wanted at +1
+  // CHECK: strong_retain %0
+  // CHECK: [[VALUE:%.*]] = open_existential_box %0
+  // CHECK: [[METHOD:%.*]] = function_ref
+  // CHECK: copy_addr [[VALUE]] to [initialization] [[COPY:%.*]]#1 :
+  // CHECK: apply [[METHOD]]<{{.*}}>([[COPY]]#1)
+  // CHECK-NOT: destroy_addr [[COPY]]
+  // CHECK-NOT: destroy_addr [[VALUE]]
+  // CHECK: dealloc_stack [[COPY]]#0
+  // CHECK-NOT: destroy_addr [[VALUE]]
+  // -- release the guarantee (TODO: redundant; see above)
+  // CHECK: strong_release %0
+  // -- release the owned argument
+  // CHECK: strong_release %0
+  error.extensionMethod()
+}