introduce 'AggressiveBorrowing' experimental feature

This is a SILGen-oriented feature and set of small
fixes that helps avoid emitting copies when they're
not needed.

The primary change when turning on this feature is
the avoidance of injecting LoadExpr's to deal with
lvalue reads, in favor of implicit BorrowExpr's

Author: kavon

include/swift/Basic/Features.def

@@ -344,6 +344,9 @@ EXPERIMENTAL_FEATURE(MoveOnlyTuples, true)
 EXPERIMENTAL_FEATURE(MoveOnlyPartialReinitialization, true)
 EXPERIMENTAL_FEATURE(ConsumeSelfInDeinit, true)
 
+/// Borrow values by default more aggressively in SILGen.
+EXPERIMENTAL_FEATURE(AggressiveBorrowing, false)
+
 EXPERIMENTAL_FEATURE(AccessLevelOnImport, true)
 
 /// Disable the special behavior of of explicit 'nonisolated' vs. being

lib/AST/ASTVerifier.cpp

@@ -2499,6 +2499,19 @@ class Verifier : public ASTWalker {
       verifyCheckedBase(E);
     }
 
+    void verifyChecked(BorrowExpr *E) {
+      PrettyStackTraceExpr debugStack(Ctx, "verifying BorrowExpr", E);
+
+      auto toType = E->getType();
+      auto fromType = E->getSubExpr()->getType();
+
+      if (!fromType->hasLValueType())
+        error("borrow source must be an l-value", E);
+
+      if (toType->hasLValueType())
+        error("borrow result must be an r-value", E);
+    }
+
     void verifyChecked(ABISafeConversionExpr *E) {
       PrettyStackTraceExpr debugStack(Ctx, "verify ABISafeConversionExpr", E);
 

lib/AST/FeatureSet.cpp

@@ -92,6 +92,7 @@ UNINTERESTING_FEATURE(OldOwnershipOperatorSpellings)
 UNINTERESTING_FEATURE(MoveOnlyEnumDeinits)
 UNINTERESTING_FEATURE(MoveOnlyTuples)
 UNINTERESTING_FEATURE(MoveOnlyPartialReinitialization)
+UNINTERESTING_FEATURE(AggressiveBorrowing)
 UNINTERESTING_FEATURE(AccessLevelOnImport)
 UNINTERESTING_FEATURE(AllowNonResilientAccessInPackage)
 UNINTERESTING_FEATURE(ClientBypassResilientAccessInPackage)

lib/SILGen/SILGenDecl.cpp

@@ -1683,6 +1683,8 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD, unsigned idx,
     }
   }
 
+  // Form an evaluation scope for the initializing expression
+  FormalEvaluationScope writeback(*this);
   emitExprInto(initExpr, initialization.get());
 }
 

lib/SILGen/SILGenExpr.cpp

@@ -467,6 +467,7 @@ namespace {
 
     RValue visitStringLiteralExpr(StringLiteralExpr *E, SGFContext C);
     RValue visitLoadExpr(LoadExpr *E, SGFContext C);
+    RValue visitBorrowExpr(BorrowExpr *E, SGFContext C);
     RValue visitDerivedToBaseExpr(DerivedToBaseExpr *E, SGFContext C);
     RValue visitMetatypeConversionExpr(MetatypeConversionExpr *E,
                                        SGFContext C);
@@ -1110,6 +1111,21 @@ RValue RValueEmitter::visitLoadExpr(LoadExpr *E, SGFContext C) {
                               C.withFollowingSideEffects());
 }
 
+RValue RValueEmitter::visitBorrowExpr(BorrowExpr *E, SGFContext C_Ignored) {
+  assert(!SGF.getTypeLowering(E->getType()).getLoweredType().isAddress()
+  && "maybe unhandled address-only type?");
+
+  // NOTE: You should NOT add an evaluation scope here!
+  // The callers of this visitor should have established a scope already that
+  // encompasses the use of the borrowed RValue that we return.
+  ASSERT(SGF.isInFormalEvaluationScope() && "emit borrow_expr without scope?");
+
+  LValue lv = SGF.emitLValue(E->getSubExpr(), SGFAccessKind::BorrowedObjectRead);
+  auto substFormalType = lv.getSubstFormalType();
+  ManagedValue mv = SGF.emitBorrowedLValue(E, std::move(lv));
+  return RValue(SGF, E, substFormalType, mv);
+}
+
 SILValue SILGenFunction::emitTemporaryAllocation(SILLocation loc, SILType ty,
                                                  HasDynamicLifetime_t dynamic,
                                                  IsLexical_t isLexical,

lib/SILGen/SILGenLValue.cpp

@@ -3756,7 +3756,7 @@ RValue SILGenFunction::emitRValueForNonMemberVarDecl(SILLocation loc,
     // This is a 'let', so we can make guarantees.
     return RValue(*this, loc, formalRValueType,
                   C.isGuaranteedPlusZeroOk()
-                    ? Result : Result.copyUnmanaged(*this, loc));
+                    ? Result : Result.ensurePlusOne(*this, loc));
   }
 
   LValue lv = emitLValueForNonMemberVarDecl(

lib/SILGen/SILGenStmt.cpp

@@ -808,7 +808,7 @@ void SILGenFunction::emitReturnExpr(SILLocation branchLoc,
                                                    loweredRetTy, loweredResultTy);
       RV = RValue(*this, ret, emitConvertedRValue(ret, conversion));
     } else {
-      RV = emitRValue(ret);
+      RV = emitRValue(ret, SGFContext::AllowImmediatePlusZero);
     }
 
     std::move(RV)

lib/Sema/CSApply.cpp

@@ -7264,6 +7264,13 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
 }
 
 Expr *ConstraintSystem::addImplicitLoadExpr(Expr *expr) {
+  /// If aggressive borrowing is enabled, don't emit a LoadExpr.
+  if (DC->getASTContext().LangOpts.hasFeature(Feature::AggressiveBorrowing)) {
+    return TypeChecker::addImplicitBorrowExpr(
+      getASTContext(), expr, [this](Expr *expr) { return getType(expr); },
+      [this](Expr *expr, Type type) { setType(expr, type); });
+  }
+
   return TypeChecker::addImplicitLoadExpr(
       getASTContext(), expr, [this](Expr *expr) { return getType(expr); },
       [this](Expr *expr, Type type) { setType(expr, type); });

lib/Sema/MiscDiagnostics.cpp

@@ -487,6 +487,10 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
     }
 
     void checkBorrowExpr(BorrowExpr *borrowExpr) {
+      // FIXME: revisit whether the restrictions are needed for explicit borrows
+      if (Ctx.LangOpts.hasFeature(AggressiveBorrowing))
+        return;
+
       // Allow for a chain of member_ref exprs that end in a decl_ref expr.
       auto *subExpr = borrowExpr->getSubExpr();
       while (auto *memberRef = dyn_cast<MemberRefExpr>(subExpr))

lib/Sema/TypeCheckConstraints.cpp

@@ -1130,6 +1130,16 @@ bool TypeChecker::checkedCastMaySucceed(Type t1, Type t2, DeclContext *dc) {
   return (kind != CheckedCastKind::Unresolved);
 }
 
+Expr *
+TypeChecker::addImplicitBorrowExpr(ASTContext &Ctx, Expr *E,
+                                 std::function<Type(Expr *)> getType,
+                                 std::function<void(Expr *, Type)> setType) {
+  auto objectType = getType(E)->getRValueType();
+  auto *BE = BorrowExpr::createImplicit(Ctx, E->getLoc(), E, objectType);
+  setType(BE, objectType);
+  return BE;
+}
+
 Expr *
 TypeChecker::addImplicitLoadExpr(ASTContext &Context, Expr *expr,
                                  std::function<Type(Expr *)> getType,