Merge pull request #6836 from gottesmm/some_more_manage_value_apis

Author: swift-ci

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");
@@ -123,7 +210,22 @@ class ManagedValue {
   SILValue getValue() const { return valueAndFlag.getPointer(); }
 
   SILType getType() const { return getValue()->getType(); }
-  
+
+  /// Transform the given ManagedValue, replacing the underlying value, but
+  /// keeping the same cleanup.
+  ///
+  /// For owned values, this is equivalent to forwarding the cleanup and
+  /// creating a new cleanup of the same type on the new value. This is useful
+  /// for forwarding sequences.
+  ///
+  /// For all other values, it is a move.
+  ManagedValue transform(SILValue newValue) && {
+    assert(getValue().getOwnershipKind() == newValue.getOwnershipKind() &&
+           "New value and old value must have the same ownership kind");
+    ManagedValue M(newValue, isLValue(), getCleanup());
+    *this = ManagedValue();
+    return M;
+  }
 
   CanType getSwiftType() const {
     return isLValue()