silgen: eliminated unused RValue emission functions

The functions `emitPlusOneRValue` and
`emitPlusOneZeroRValue` of SILGenFunction,
are unused and not fully implemented.

Author: kavon

lib/SILGen/SILGenExpr.cpp

@@ -7505,24 +7505,6 @@ RValue SILGenFunction::emitRValue(Expr *E, SGFContext C) {
   return RValueEmitter(*this).visit(E, C);
 }
 
-RValue SILGenFunction::emitPlusOneRValue(Expr *E, SGFContext C) {
-  Scope S(*this, SILLocation(E));
-  assert(!E->getType()->hasLValueType() &&
-         "l-values must be emitted with emitLValue");
-  return S.popPreservingValue(
-      RValueEmitter(*this).visit(E, C.withSubExprSideEffects()));
-}
-
-RValue SILGenFunction::emitPlusZeroRValue(Expr *E) {
-  // Check if E is a case that we know how to emit at plus zero. If so, handle
-  // it here.
-  //
-  // TODO: Fill this in.
-
-  // Otherwise, we go through the +1 path and borrow the result.
-  return emitPlusOneRValue(E).borrow(*this, SILLocation(E));
-}
-
 static void emitIgnoredPackExpansion(SILGenFunction &SGF,
                                      PackExpansionExpr *E) {
   auto expansionType =

lib/SILGen/SILGenFunction.h

@@ -1827,21 +1827,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                             StorageReferenceOperationKind kind);
   Expr *findStorageReferenceExprForBorrowExpr(Expr *argExpr);
 
-  /// Emit the given expression as a +1 r-value.
-  ///
-  /// *NOTE* This creates the +1 r-value and then pushes that +1 r-value through
-  /// a scope. So all temporaries resulting will be cleaned up.
-  ///
-  /// *NOTE* +0 vs +1 is ignored by this function. The only reason to use the
-  /// SGFContext argument is to pass in an initialization.
-  RValue emitPlusOneRValue(Expr *E, SGFContext C = SGFContext());
-
-  /// Emit the given expression as a +0 r-value.
-  ///
-  /// *NOTE* This does not scope the creation of the +0 r-value. The reason why
-  /// this is done is that +0 r-values can not be pushed through scopes.
-  RValue emitPlusZeroRValue(Expr *E);
-
   /// Emit the given expression as an r-value with the given conversion
   /// context.  This may be more efficient --- and, in some cases,
   /// semantically different --- than emitting the expression and then