Merge pull request swiftlang#12787 from slavapestov/simpler-apply-lowering

Simplify SILGenApply some more

Author: slavapestov

lib/SILGen/ArgumentSource.cpp

@@ -55,7 +55,6 @@ void ArgumentSource::rewriteType(CanType newType) & {
   case Kind::Tuple:
     llvm_unreachable("cannot rewrite type of tuple");
   case Kind::RValue:
-  case Kind::DelayedBorrowedRValue:
     Storage.get<RValueStorage>(StoredKind).Value.rewriteType(newType);
     return;
   case Kind::Expr:
@@ -89,7 +88,6 @@ bool ArgumentSource::requiresCalleeToEvaluate() const {
   case Kind::Invalid:
     llvm_unreachable("argument source is invalid");
   case Kind::RValue:
-  case Kind::DelayedBorrowedRValue:
   case Kind::LValue:
     return false;
   case Kind::Expr:
@@ -138,9 +136,6 @@ RValue ArgumentSource::getAsRValue(SILGenFunction &SGF, SGFContext C) && {
     llvm_unreachable("argument source is invalid");
   case Kind::LValue:
     llvm_unreachable("cannot get l-value as r-value");
-  case Kind::DelayedBorrowedRValue:
-    return std::move(*this).asKnownRValue(SGF).borrow(SGF,
-                                                      getKnownRValueLocation());
   case Kind::RValue:
     return std::move(*this).asKnownRValue(SGF);
   case Kind::Expr:
@@ -195,15 +190,6 @@ ManagedValue ArgumentSource::getAsSingleValue(SILGenFunction &SGF,
     return SGF.emitAddressOfLValue(loc, std::move(*this).asKnownLValue(),
                                    AccessKind::ReadWrite);
   }
-  case Kind::DelayedBorrowedRValue: {
-    assert(!C.getEmitInto() &&
-           "Can not put a delayed borrowed rvalue into an initialization");
-    auto loc = getKnownRValueLocation();
-    return std::move(*this)
-        .asKnownRValue(SGF)
-        .getAsSingleValue(SGF, loc)
-        .borrow(SGF, loc);
-  }
   case Kind::RValue: {
     auto loc = getKnownRValueLocation();
     if (auto init = C.getEmitInto()) {
@@ -250,9 +236,6 @@ ManagedValue ArgumentSource::getConverted(SILGenFunction &SGF,
     llvm_unreachable("argument source is invalid");
   case Kind::LValue:
     llvm_unreachable("cannot get converted l-value");
-  case Kind::DelayedBorrowedRValue:
-    // TODO: We probably can, but we would need to introduce a copy.
-    llvm_unreachable("cannot get converted borrowed r-value");
   case Kind::RValue:
   case Kind::Expr:
   case Kind::Tuple:
@@ -270,8 +253,6 @@ void ArgumentSource::forwardInto(SILGenFunction &SGF, Initialization *dest) && {
     llvm_unreachable("argument source is invalid");
   case Kind::LValue:
     llvm_unreachable("cannot forward an l-value");
-  case Kind::DelayedBorrowedRValue:
-    llvm_unreachable("cannot forward a delayed borrowed r-value");
   case Kind::RValue: {
     auto loc = getKnownRValueLocation();
     std::move(*this).asKnownRValue(SGF).forwardInto(SGF, loc, dest);
@@ -299,26 +280,12 @@ ArgumentSource::ArgumentSource(SILLocation loc, RValue &&rv, Kind kind)
   Storage.emplaceAggregate<RValueStorage>(StoredKind, std::move(rv), loc);
 }
 
-ArgumentSource ArgumentSource::delayedBorrow(SILGenFunction &SGF) const & {
-  assert(isRValue() && "Can only perform a delayed borrow on an rvalue");
-  // We are doing something evil here since we know that we are going to perform
-  // a borrow.
-  //
-  // Once uncurrying is removed from the compiler, we will no longer need to
-  // perform delayed borrows and this evilness can be expunged.
-  const RValue &rv = asKnownRValue();
-  return ArgumentSource(getKnownRValueLocation(),
-                        RValue(&SGF, rv.values, rv.type),
-                        Kind::DelayedBorrowedRValue);
-}
-
 ArgumentSource ArgumentSource::borrow(SILGenFunction &SGF) const & {
   switch (StoredKind) {
   case Kind::Invalid:
     llvm_unreachable("argument source is invalid");
   case Kind::LValue:
     llvm_unreachable("cannot borrow an l-value");
-  case Kind::DelayedBorrowedRValue:
   case Kind::RValue: {
     auto loc = getKnownRValueLocation();
     return ArgumentSource(loc, asKnownRValue().borrow(SGF, loc));
@@ -449,7 +416,6 @@ void ArgumentSource::dump(raw_ostream &out, unsigned indent) const {
     return;
   }
   case Kind::RValue:
-  case Kind::DelayedBorrowedRValue:
     out << "RValue\n";
     Storage.get<RValueStorage>(StoredKind).Value.dump(out, indent + 2);
     return;

lib/SILGen/ArgumentSource.h

@@ -52,8 +52,6 @@ class ArgumentSource {
   enum class Kind : unsigned char {
     Invalid,
     RValue,
-    // An RValue that will be borrowed when emitted.
-    DelayedBorrowedRValue,
     LValue,
     Expr,
     Tuple,
@@ -91,7 +89,6 @@ class ArgumentSource {
     switch (kind) {
     case Kind::Invalid: return StorageMembers::indexOf<void>();
     case Kind::RValue:
-    case Kind::DelayedBorrowedRValue:
       return StorageMembers::indexOf<RValueStorage>();
     case Kind::LValue: return StorageMembers::indexOf<LValueStorage>();
     case Kind::Expr: return StorageMembers::indexOf<Expr*>();
@@ -147,7 +144,6 @@ class ArgumentSource {
     case Kind::Invalid:
       return false;
     case Kind::RValue:
-    case Kind::DelayedBorrowedRValue:
       return !asKnownRValue().isNull();
     case Kind::LValue:
       return asKnownLValue().isValid();
@@ -164,7 +160,6 @@ class ArgumentSource {
     case Kind::Invalid:
       llvm_unreachable("argument source is invalid");
     case Kind::RValue:
-    case Kind::DelayedBorrowedRValue:
       return asKnownRValue().getType();
     case Kind::LValue:
       return CanInOutType::get(asKnownLValue().getSubstFormalType());
@@ -183,7 +178,6 @@ class ArgumentSource {
     case Kind::Invalid:
       llvm_unreachable("argument source is invalid");
     case Kind::RValue:
-    case Kind::DelayedBorrowedRValue:
       return asKnownRValue().getType();
     case Kind::LValue:
       return asKnownLValue().getSubstFormalType();
@@ -201,7 +195,6 @@ class ArgumentSource {
     switch (StoredKind) {
     case Kind::Invalid: llvm_unreachable("argument source is invalid");
     case Kind::RValue:
-    case Kind::DelayedBorrowedRValue:
       return false;
     case Kind::LValue: return true;
     case Kind::Expr: return asKnownExpr()->isSemanticallyInOutExpr();
@@ -215,7 +208,6 @@ class ArgumentSource {
     case Kind::Invalid:
       llvm_unreachable("argument source is invalid");
     case Kind::RValue:
-    case Kind::DelayedBorrowedRValue:
       return getKnownRValueLocation();
     case Kind::LValue:
       return getKnownLValueLocation();
@@ -228,21 +220,13 @@ class ArgumentSource {
   }
 
   bool isExpr() const & { return StoredKind == Kind::Expr; }
-  bool isRValue() const & {
-    return StoredKind == Kind::RValue ||
-           StoredKind == Kind::DelayedBorrowedRValue;
-  }
+  bool isRValue() const & { return StoredKind == Kind::RValue; }
   bool isLValue() const & { return StoredKind == Kind::LValue; }
   bool isTuple() const & { return StoredKind == Kind::Tuple; }
 
   /// Given that this source is storing an RValue, extract and clear
   /// that value.
   RValue &&asKnownRValue(SILGenFunction &SGF) && {
-    if (isDelayedBorrowedRValue()) {
-      std::move(Storage.get<RValueStorage>(StoredKind).Value)
-          .borrow(SGF, getKnownRValueLocation());
-    }
-
     return std::move(Storage.get<RValueStorage>(StoredKind).Value);
   }
 
@@ -313,15 +297,6 @@ class ArgumentSource {
   /// return the ArgumentSource. Otherwise, assert.
   ArgumentSource borrow(SILGenFunction &SGF) const &;
 
-  /// If we have an rvalue, return an Argument Source that when the RValue is
-  /// retrieved, the RValue is always borrowed first.
-  ///
-  /// This allows us to specify when creating callees that a value must be
-  /// borrowed, but emit the actual borrow once the callee is evaluated later in
-  /// SILGenApply. Ideally, the callee would always eagerly borrow, but since we
-  /// still have uncurrying, we can not do that.
-  ArgumentSource delayedBorrow(SILGenFunction &SGF) const &;
-
   ManagedValue materialize(SILGenFunction &SGF) &&;
 
   /// Emit this value to memory so that it follows the abstraction
@@ -346,14 +321,6 @@ class ArgumentSource {
   /// Private helper constructor for delayed borrowed rvalues.
   ArgumentSource(SILLocation loc, RValue &&rv, Kind kind);
 
-  /// Returns true if this ArgumentSource stores a delayed borrowed RValue.
-  ///
-  /// This is private since we do not want users to be able to determine if the
-  /// given ArgumentSource is a normal RValue or a delayed borrow rvalue.
-  bool isDelayedBorrowedRValue() const & {
-    return StoredKind == Kind::DelayedBorrowedRValue;
-  }
-
   // Make the non-move accessors private to make it more difficult
   // to accidentally re-emit values.
   const RValue &asKnownRValue() const & {