[+0-normal-args] Use SILGenBuilder in SILGenConvert when injecting an optional so we propagate through +0 vs +1.

This commit does two different things:

1. Changes some code paths in SILGenConvert to use SILGenBuilder APIs.
2. It eliminates a few bugs in this path exposed by running the SILGen tests
with +0 enabled.

The bug specifically is that we are assuming in this code that the input value
is always at +1, so we unconditionally forward the input value and then create
destroys on the output. This is not correct in general (since we have guaranteed
values) and occurs all the time with +0 arguments enabled.

This is tested by running the SILGen tests with +0 arguments enabled.

rdar://34222540

Author: gottesmm

lib/SILGen/SILGenBuilder.cpp

@@ -691,6 +691,14 @@ ManagedValue SILGenBuilder::createOpenExistentialBoxValue(SILLocation loc,
   return ManagedValue::forUnmanaged(openedExistential);
 }
 
+ManagedValue SILGenBuilder::createOpenExistentialMetatype(SILLocation loc,
+                                                          ManagedValue value,
+                                                          SILType openedType) {
+  SILValue result = SILGenBuilder::createOpenExistentialMetatype(
+      loc, value.getValue(), openedType);
+  return ManagedValue::forTrivialRValue(result);
+}
+
 ManagedValue SILGenBuilder::createStore(SILLocation loc, ManagedValue value,
                                         SILValue address,
                                         StoreOwnershipQualifier qualifier) {

lib/SILGen/SILGenBuilder.h

@@ -313,6 +313,11 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue createOpenExistentialBoxValue(SILLocation loc,
                                           ManagedValue original, SILType type);
 
+  using SILBuilder::createOpenExistentialMetatype;
+  ManagedValue createOpenExistentialMetatype(SILLocation loc,
+                                             ManagedValue value,
+                                             SILType openedType);
+
   /// Convert a @convention(block) value to AnyObject.
   ManagedValue createBlockToAnyObject(SILLocation loc, ManagedValue block,
                                       SILType type);

lib/SILGen/SILGenConvert.cpp

@@ -50,8 +50,7 @@ SILGenFunction::emitInjectOptional(SILLocation loc,
   // TODO: honor +0 contexts?
   if (optTL.isLoadable() || !silConv.useLoweredAddresses()) {
     ManagedValue objectResult = generator(SGFContext());
-    auto some = B.createEnum(loc, objectResult.forward(*this), someDecl, optTy);
-    return emitManagedRValueWithCleanup(some, optTL);
+    return B.createEnum(loc, objectResult, someDecl, optTy);
   }
 
   // Otherwise it's address-only; try to avoid spurious copies by
@@ -131,10 +130,8 @@ getOptionalSomeValue(SILLocation loc, ManagedValue value,
 
   assert(formalOptType.getOptionalObjectType());
   auto someDecl = getASTContext().getOptionalSomeDecl();
-  
-  SILValue result =
-    B.createEnum(loc, value.forward(*this), someDecl, optTL.getLoweredType());
-  return emitManagedRValueWithCleanup(result, optTL);
+
+  return B.createEnum(loc, value, someDecl, optTL.getLoweredType());
 }
 
 auto SILGenFunction::emitSourceLocationArgs(SourceLoc sourceLoc,
@@ -864,22 +861,16 @@ SILGenFunction::emitOpenExistential(
   }
   case ExistentialRepresentation::Metatype:
     assert(existentialType.isObject());
-    archetypeMV =
-        ManagedValue::forUnmanaged(
-            B.createOpenExistentialMetatype(
-                       loc, existentialValue.forward(*this),
-                       loweredOpenedType));
+    archetypeMV = B.createOpenExistentialMetatype(
+        loc, existentialValue, loweredOpenedType);
     // Metatypes are always trivial. Consuming would be a no-op.
     canConsume = false;
     break;
   case ExistentialRepresentation::Class: {
     assert(existentialType.isObject());
-    SILValue archetypeValue = B.createOpenExistentialRef(
-                       loc, existentialValue.forward(*this),
-                       loweredOpenedType);
-    canConsume = existentialValue.hasCleanup();
-    archetypeMV = (canConsume ? emitManagedRValueWithCleanup(archetypeValue)
-                              : ManagedValue::forUnmanaged(archetypeValue));
+    archetypeMV =
+        B.createOpenExistentialRef(loc, existentialValue, loweredOpenedType);
+    canConsume = archetypeMV.hasCleanup();
     break;
   }
   case ExistentialRepresentation::Boxed: