[semantic-sil] Introduce new specific static constructors for ManagedValue.

This is the first step towards eliminating:

* ManagedValue::forUnmanaged(SILValue)
* ManagedValue::ManagedValue(SILValue, CleanupHandle).

The reason why these two methods must be eliminated is that:

1. Currently non-trivial values are "borrowed" using
ManagedValue::forUnmanaged. With Semantic SIL, we are now able to represent
borrows via begin_borrow and end_borrow. This will make the semantics that
SILGen is trying to describe more accurate.

2. ManagedValue::ManagedValue can be used to add arbitrary cleanups. We want
methods that add cleanups, but that at the same time allow the caller to specify
what it expects the ownership of the given SILValue to be. This would then cause
an assertion to trip giving greater clarity.

rdar://29791263

Author: gottesmm

lib/SILGen/ManagedValue.h

@@ -66,19 +66,106 @@ class ManagedValue {
 public:
 
   ManagedValue() = default;
-  
+
   /// Create a managed value for a +1 rvalue.
+  ///
+  /// Please do not introduce new uses of this method! Instead use one of the
+  /// static constructors below.
   ManagedValue(SILValue value, CleanupHandle cleanup)
     : valueAndFlag(value, false), cleanup(cleanup) {
-    assert(value && "No value specified");
+    assert(value && "No value specified?!");
   }
 
   /// Create a managed value for a +0 rvalue.
+  ///
+  /// Please do not introduce new uses of this method! Instead use one of the
+  /// static constructors below!
   static ManagedValue forUnmanaged(SILValue value) {
     assert(value && "No value specified");
     return ManagedValue(value, false, CleanupHandle::invalid());
   }
 
+  /// Create a managed value for a +1 rvalue object.
+  static ManagedValue forOwnedObjectRValue(SILValue value,
+                                           CleanupHandle cleanup) {
+    assert(value && "No value specified");
+    assert(value->getType().isObject() &&
+           "Expected borrowed rvalues to be objects");
+    assert(value.getOwnershipKind() != ValueOwnershipKind::Trivial);
+    return ManagedValue(value, false, cleanup);
+  }
+
+  /// Create a managed value for a +1 rvalue address.
+  ///
+  /// From a high level perspective, this consists of a temporary buffer.
+  static ManagedValue forOwnedAddressRValue(SILValue value,
+                                            CleanupHandle cleanup) {
+    assert(value && "No value specified");
+    assert(value->getType().isAddress() && "Expected value to be an address");
+    assert(value.getOwnershipKind() == ValueOwnershipKind::Trivial &&
+           "Addresses always have trivial ownership");
+    return ManagedValue(value, false, cleanup);
+  }
+
+  /// Create a managed value for a +1 non-trivial rvalue.
+  static ManagedValue forOwnedRValue(SILValue value, CleanupHandle cleanup) {
+    if (value->getType().isAddress())
+      return ManagedValue::forOwnedAddressRValue(value, cleanup);
+    return ManagedValue::forOwnedObjectRValue(value, cleanup);
+  }
+
+  /// Create a managed value for a +0 borrowed non-trivial rvalue object.
+  static ManagedValue
+  forBorrowedObjectRValue(SILValue value,
+                          CleanupHandle cleanup = CleanupHandle::invalid()) {
+    assert(value && "No value specified");
+    assert(value->getType().isObject() &&
+           "Expected borrowed rvalues to be objects");
+    assert(value.getOwnershipKind() != ValueOwnershipKind::Trivial);
+    return ManagedValue(value, false, cleanup);
+  }
+
+  /// Create a managed value for a +0 borrowed non-trivial rvalue address.
+  static ManagedValue
+  forBorrowedAddressRValue(SILValue value,
+                           CleanupHandle cleanup = CleanupHandle::invalid()) {
+    assert(value && "No value specified");
+    assert(value->getType().isAddress() && "Expected value to be an address");
+    assert(value.getOwnershipKind() == ValueOwnershipKind::Trivial &&
+           "Addresses always have trivial ownership");
+    return ManagedValue(value, false, cleanup);
+  }
+
+  /// Create a managed value for a +0 guaranteed rvalue.
+  static ManagedValue
+  forBorrowedRValue(SILValue value,
+                    CleanupHandle cleanup = CleanupHandle::invalid()) {
+    if (value->getType().isAddress())
+      return ManagedValue::forBorrowedAddressRValue(value, cleanup);
+    return ManagedValue::forBorrowedObjectRValue(value, cleanup);
+  }
+
+  /// Create a managed value for a +0 trivial object rvalue.
+  static ManagedValue forTrivialObjectRValue(SILValue value) {
+    assert(value->getType().isObject() && "Expected an object");
+    assert(value.getOwnershipKind() == ValueOwnershipKind::Trivial);
+    return ManagedValue(value, false, CleanupHandle::invalid());
+  }
+
+  /// Create a managed value for a +0 trivial address rvalue.
+  static ManagedValue forTrivialAddressRValue(SILValue value) {
+    assert(value->getType().isAddress() && "Expected an address");
+    assert(value.getOwnershipKind() == ValueOwnershipKind::Trivial);
+    return ManagedValue(value, false, CleanupHandle::invalid());
+  }
+
+  /// Create a managed value for a +0 trivial rvalue.
+  static ManagedValue forTrivialRValue(SILValue value) {
+    if (value->getType().isObject())
+      return ManagedValue::forTrivialObjectRValue(value);
+    return ManagedValue::forTrivialAddressRValue(value);
+  }
+
   /// Create a managed value for an l-value.
   static ManagedValue forLValue(SILValue value) {
     assert(value && "No value specified");