[silgen] Add support for borrowing an RValue.

I also changed the way RValues are copied API wise to match how borrows are
copied.

rdar://33358110

Author: gottesmm

lib/SILGen/ManagedValue.cpp

@@ -23,7 +23,7 @@ using namespace swift;
 using namespace Lowering;
 
 /// Emit a copy of this value with independent ownership.
-ManagedValue ManagedValue::copy(SILGenFunction &SGF, SILLocation loc) {
+ManagedValue ManagedValue::copy(SILGenFunction &SGF, SILLocation loc) const {
   auto &lowering = SGF.getTypeLowering(getType());
   if (lowering.isTrivial())
     return *this;

lib/SILGen/ManagedValue.h

@@ -236,7 +236,7 @@ class ManagedValue {
   }
 
   /// Emit a copy of this value with independent ownership.
-  ManagedValue copy(SILGenFunction &SGF, SILLocation loc);
+  ManagedValue copy(SILGenFunction &SGF, SILLocation loc) const;
 
   /// Emit a copy of this value with independent ownership into the current
   /// formal evaluation scope.

lib/SILGen/RValue.cpp

@@ -672,16 +672,26 @@ void RValue::extractElements(SmallVectorImpl<RValue> &elements) && {
   makeUsed();
 }
 
-RValue::RValue(const RValue &copied, SILGenFunction &SGF, SILLocation l)
-  : type(copied.type),
-    elementsToBeAdded(copied.elementsToBeAdded)
-{
-  assert((copied.isComplete() || copied.isInSpecialState())
-         && "can't copy incomplete rvalue");
-  values.reserve(copied.values.size());
-  for (ManagedValue value : copied.values) {
-    values.push_back(value.copy(SGF, l));
+RValue RValue::copy(SILGenFunction &SGF, SILLocation loc) const & {
+  assert((isComplete() || isInSpecialState()) &&
+         "can't copy an incomplete rvalue");
+  std::vector<ManagedValue> copiedValues;
+  copiedValues.reserve(values.size());
+  for (ManagedValue v : values) {
+    copiedValues.emplace_back(v.copy(SGF, loc));
   }
+  return RValue(std::move(copiedValues), type, elementsToBeAdded);
+}
+
+RValue RValue::borrow(SILGenFunction &SGF, SILLocation loc) const & {
+  assert((isComplete() || isInSpecialState()) &&
+         "can't borrow incomplete rvalue");
+  std::vector<ManagedValue> borrowedValues;
+  borrowedValues.reserve(values.size());
+  for (ManagedValue v : values) {
+    borrowedValues.emplace_back(v.borrow(SGF, loc));
+  }
+  return RValue(std::move(borrowedValues), type, elementsToBeAdded);
 }
 
 ManagedValue RValue::materialize(SILGenFunction &SGF, SILLocation loc) && {
@@ -731,6 +741,7 @@ bool RValue::areObviouslySameValue(SILValue lhs, SILValue rhs) {
 void RValue::dump() const {
   dump(llvm::errs());
 }
+
 void RValue::dump(raw_ostream &OS, unsigned indent) const {
   if (isInContext()) {
     OS.indent(indent) << "InContext\n";

lib/SILGen/RValue.h

@@ -33,8 +33,10 @@ class Initialization;
 class SILGenFunction;
 
 /// An "exploded" SIL rvalue, in which tuple values are recursively
-/// destructured. (In SILGen we don't try to explode structs, because doing so
-/// would require considering resilience, a job we want to delegate to IRGen).
+/// destructured.
+///
+/// *NOTE* In SILGen we don't try to explode structs, because doing so would
+/// require considering resilience, a job we want to delegate to IRGen.
 class RValue {
   std::vector<ManagedValue> values;
   CanType type;
@@ -60,12 +62,18 @@ class RValue {
     elementsToBeAdded = Used;
     values = {};
   }
-  
-  /// Private constructor used by copy().
-  RValue(const RValue &copied, SILGenFunction &SGF, SILLocation l);
-  
-  /// Construct an RValue from a pre-exploded set of
-  /// ManagedValues. Used to implement the extractElement* methods.
+
+  /// Private constructor used by copy() and borrow().
+  RValue(std::vector<ManagedValue> &&values, CanType type,
+         unsigned elementsToBeAdded)
+      : values(std::move(values)), type(type),
+        elementsToBeAdded(elementsToBeAdded) {}
+
+  /// Construct an RValue from a pre-exploded set of ManagedValues.
+  ///
+  /// Used to implement the extractElement* methods. *NOTE* This constructor
+  /// assumes that the constructed RValue is fully formed and thus has
+  /// elementsToBeAdded set to zero.
   RValue(ArrayRef<ManagedValue> values, CanType type);
 
   RValue(unsigned state) : elementsToBeAdded(state) {
@@ -106,8 +114,9 @@ class RValue {
   /// will be exploded.
   RValue(SILGenFunction &SGF, SILLocation l, CanType type, ManagedValue v);
 
-  /// Construct an RValue from a pre-exploded set of
-  /// ManagedValues. Used to implement the extractElement* methods.
+  /// Construct an RValue from a pre-exploded set of ManagedValues.
+  ///
+  /// This is used to implement the extractElement* methods.
   static RValue withPreExplodedElements(ArrayRef<ManagedValue> values,
                                         CanType type);
 
@@ -259,9 +268,10 @@ class RValue {
   }
 
   /// Emit an equivalent value with independent ownership.
-  RValue copy(SILGenFunction &SGF, SILLocation l) const & {
-    return RValue(*this, SGF, l);
-  }
+  RValue copy(SILGenFunction &SGF, SILLocation loc) const &;
+
+  /// Borrow all subvalues of the rvalue.
+  RValue borrow(SILGenFunction &SGF, SILLocation loc) const &;
 
   static bool areObviouslySameValue(SILValue lhs, SILValue rhs);
   bool isObviouslyEqual(const RValue &rhs) const;