[copy-operator] Add support for the copy operator in preparation for making consuming and borrowing no implicit copy.

Some notes:

1. I implemented this as a contextual keyword that can only apply directly to
lvalues. This ensures that we can still call functions called copy, define
variables named copy, etc. I added tests for both the c++ and swift-syntax based
parsers to validate this. So there shouldn't be any source breaks.

2. I did a little bit of type checker work to ensure that we do not treat
copy_expr's result as an lvalue. Otherwise, one could call mutating functions on
it or assign to it, which we do not want since the result of copy_value is

3. As expected, by creating a specific expr, I was able to have much greater
control of the SILGen codegen and thus eliminate extraneous copies and other
weirdness than if we used a function and had to go through SILGenApply.

rdar://101862423

Author: gottesmm

include/swift/AST/DiagnosticsParse.def

@@ -1386,6 +1386,8 @@ ERROR(expected_expr_after_await, none,
       "expected expression after 'await'", ())
 ERROR(expected_expr_after_move, none,
       "expected expression after 'consume'", ())
+ERROR(expected_expr_after_copy, none,
+      "expected expression after 'copy'", ())
 ERROR(expected_expr_after_borrow, none,
       "expected expression after '_borrow'", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -6996,6 +6996,10 @@ ERROR(move_expression_not_passed_lvalue,none,
       "'consume' can only be applied to lvalues", ())
 ERROR(borrow_expression_not_passed_lvalue,none,
       "'borrow' can only be applied to lvalues", ())
+ERROR(copy_expression_not_passed_lvalue,none,
+      "'copy' can only be applied to lvalues", ())
+ERROR(copy_expression_cannot_be_used_with_noncopyable_types,none,
+      "'copy' cannot be applied to noncopyable types", ())
 
 ERROR(moveOnly_requires_lexical_lifetimes,none,
       "noncopyable types require lexical borrow scopes "

include/swift/AST/Expr.h

@@ -2077,6 +2077,33 @@ class MoveExpr final : public IdentityExpr {
   static bool classof(const Expr *e) { return e->getKind() == ExprKind::Move; }
 };
 
+/// CopyExpr - A 'copy' surrounding an lvalue expression marking the lvalue as
+/// needing a semantic copy. Used to force a copy of a no implicit copy type.
+class CopyExpr final : public Expr {
+  Expr *SubExpr;
+  SourceLoc CopyLoc;
+
+public:
+  CopyExpr(SourceLoc copyLoc, Expr *sub, Type type = Type(),
+           bool implicit = false)
+      : Expr(ExprKind::Copy, implicit, type), SubExpr(sub), CopyLoc(copyLoc) {}
+
+  static CopyExpr *createImplicit(ASTContext &ctx, SourceLoc copyLoc, Expr *sub,
+                                  Type type = Type()) {
+    return new (ctx) CopyExpr(copyLoc, sub, type, /*implicit=*/true);
+  }
+
+  SourceLoc getLoc() const { return CopyLoc; }
+
+  Expr *getSubExpr() const { return SubExpr; }
+  void setSubExpr(Expr *E) { SubExpr = E; }
+
+  SourceLoc getStartLoc() const { return CopyLoc; }
+  SourceLoc getEndLoc() const { return getSubExpr()->getEndLoc(); }
+
+  static bool classof(const Expr *e) { return e->getKind() == ExprKind::Copy; }
+};
+
 /// BorrowExpr - A 'borrow' surrounding an lvalue/accessor expression at an
 /// apply site marking the lvalue/accessor as being borrowed when passed to the
 /// callee.

include/swift/AST/ExprNodes.def

@@ -111,6 +111,7 @@ ABSTRACT_EXPR(Identity, Expr)
   EXPR(Borrow, IdentityExpr)
   EXPR(UnresolvedMemberChainResult, IdentityExpr)
   EXPR_RANGE(Identity, Paren, UnresolvedMemberChainResult)
+EXPR(Copy, Expr)
 ABSTRACT_EXPR(AnyTry, Expr)
   EXPR(Try, AnyTryExpr)
   EXPR(ForceTry, AnyTryExpr)

lib/AST/ASTDumper.cpp

@@ -2200,6 +2200,12 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
+  void visitCopyExpr(CopyExpr *E) {
+    printCommon(E, "copy_expr");
+    OS << '\n';
+    printRec(E->getSubExpr());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
   void visitBorrowExpr(BorrowExpr *E) {
     printCommon(E, "borrow_expr");
     OS << '\n';

lib/AST/ASTPrinter.cpp

@@ -5001,6 +5001,11 @@ void PrintAST::visitMoveExpr(MoveExpr *expr) {
   visit(expr->getSubExpr());
 }
 
+void PrintAST::visitCopyExpr(CopyExpr *expr) {
+  Printer << "copy ";
+  visit(expr->getSubExpr());
+}
+
 void PrintAST::visitBorrowExpr(BorrowExpr *expr) {
   Printer << "borrow ";
   visit(expr->getSubExpr());

lib/AST/ASTWalker.cpp

@@ -690,6 +690,15 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     }
     return nullptr;
   }
+
+  Expr *visitCopyExpr(CopyExpr *E) {
+    if (Expr *subExpr = doIt(E->getSubExpr())) {
+      E->setSubExpr(subExpr);
+      return E;
+    }
+    return nullptr;
+  }
+
   Expr *visitTupleExpr(TupleExpr *E) {
     for (unsigned i = 0, e = E->getNumElements(); i != e; ++i)
       if (E->getElement(i)) {

lib/AST/Expr.cpp

@@ -192,7 +192,6 @@ SourceLoc Expr::getLoc() const {
 Expr *Expr::getSemanticsProvidingExpr() {
   if (auto *IE = dyn_cast<IdentityExpr>(this))
     return IE->getSubExpr()->getSemanticsProvidingExpr();
-
   if (auto *TE = dyn_cast<TryExpr>(this))
     return TE->getSubExpr()->getSemanticsProvidingExpr();
 
@@ -372,6 +371,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(DotSelf, getSubExpr);
   PASS_THROUGH_REFERENCE(Await, getSubExpr);
   PASS_THROUGH_REFERENCE(Move, getSubExpr);
+  PASS_THROUGH_REFERENCE(Copy, getSubExpr);
   PASS_THROUGH_REFERENCE(Borrow, getSubExpr);
   PASS_THROUGH_REFERENCE(Try, getSubExpr);
   PASS_THROUGH_REFERENCE(ForceTry, getSubExpr);
@@ -744,6 +744,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
 
   case ExprKind::Await:
   case ExprKind::Move:
+  case ExprKind::Copy:
   case ExprKind::Borrow:
   case ExprKind::Try:
   case ExprKind::ForceTry:
@@ -936,6 +937,7 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::Paren:
   case ExprKind::Await:
   case ExprKind::Move:
+  case ExprKind::Copy:
   case ExprKind::Borrow:
   case ExprKind::UnresolvedMemberChainResult:
   case ExprKind::Try:

lib/Parse/ParseExpr.cpp

@@ -422,6 +422,21 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
     return sub;
   }
 
+  if (Tok.isContextualKeyword("copy") &&
+      peekToken().isAny(tok::identifier, tok::kw_self, tok::dollarident,
+                        tok::code_complete) &&
+      !peekToken().isAtStartOfLine()) {
+    Tok.setKind(tok::contextual_keyword);
+
+    SourceLoc copyLoc = consumeToken();
+    ParserResult<Expr> sub =
+        parseExprSequenceElement(diag::expected_expr_after_copy, isExprBasic);
+    if (!sub.isNull()) {
+      sub = makeParserResult(new (Context) CopyExpr(copyLoc, sub.get()));
+    }
+    return sub;
+  }
+
   if (Context.LangOpts.hasFeature(Feature::OldOwnershipOperatorSpellings)) {
     if (Tok.isContextualKeyword("_move")) {
       Tok.setKind(tok::contextual_keyword);

lib/SILGen/SILGenBuilder.cpp

@@ -1050,3 +1050,9 @@ void SILGenBuilder::emitCopyAddrOperation(SILLocation loc, SILValue srcAddr,
   auto &lowering = getTypeLowering(srcAddr->getType());
   lowering.emitCopyInto(*this, loc, srcAddr, destAddr, isTake, isInitialize);
 }
+
+ManagedValue SILGenBuilder::createExplicitCopyValue(SILLocation loc,
+                                                    ManagedValue operand) {
+  auto cvi = SILBuilder::createExplicitCopyValue(loc, operand.getValue());
+  return SGF.emitManagedRValueWithCleanup(cvi);
+}

lib/SILGen/SILGenBuilder.h

@@ -125,6 +125,13 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue createFormalAccessCopyValue(SILLocation loc,
                                            ManagedValue originalValue);
 
+  using SILBuilder::createExplicitCopyValue;
+
+  /// A copy_value operation that to the move checker looks like just a normal
+  /// liveness use. Used to implement an explicit copy for no implicit copy
+  /// values.
+  ManagedValue createExplicitCopyValue(SILLocation Loc, ManagedValue operand);
+
 #define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
   using SILBuilder::createStrongCopy##Name##Value;                             \
   ManagedValue createStrongCopy##Name##Value(SILLocation loc,                  \

lib/SILGen/SILGenExpr.cpp

@@ -552,6 +552,7 @@ namespace {
     RValue visitLinearToDifferentiableFunctionExpr(
         LinearToDifferentiableFunctionExpr *E, SGFContext C);
     RValue visitMoveExpr(MoveExpr *E, SGFContext C);
+    RValue visitCopyExpr(CopyExpr *E, SGFContext C);
     RValue visitMacroExpansionExpr(MacroExpansionExpr *E, SGFContext C);
   };
 } // end anonymous namespace
@@ -6156,6 +6157,64 @@ RValue RValueEmitter::visitMoveExpr(MoveExpr *E, SGFContext C) {
   return RValue(SGF, {optTemp->getManagedAddress()}, subType.getASTType());
 }
 
+RValue RValueEmitter::visitCopyExpr(CopyExpr *E, SGFContext C) {
+  auto *subExpr = E->getSubExpr();
+  auto subASTType = subExpr->getType()->getCanonicalType();
+  auto subType = SGF.getLoweredType(subASTType);
+
+  if (auto *li = dyn_cast<LoadExpr>(subExpr)) {
+
+    FormalEvaluationScope writeback(SGF);
+    LValue lv =
+        SGF.emitLValue(li->getSubExpr(), SGFAccessKind::BorrowedAddressRead);
+    auto address = SGF.emitAddressOfLValue(subExpr, std::move(lv));
+
+    if (subType.isLoadable(SGF.F)) {
+      // Use a formal access load borrow so this closes in the writeback scope
+      // above.
+      ManagedValue value = SGF.B.createFormalAccessLoadBorrow(E, address);
+
+      // We purposely, use a lexical cleanup here so that the cleanup lasts
+      // through the formal evaluation scope.
+      ManagedValue copy = SGF.B.createExplicitCopyValue(E, value);
+
+      return RValue(SGF, {copy}, subType.getASTType());
+    }
+
+    auto optTemp = SGF.emitTemporary(E, SGF.getTypeLowering(subType));
+    SILValue toAddr = optTemp->getAddressForInPlaceInitialization(SGF, E);
+    SGF.B.createExplicitCopyAddr(subExpr, address.getLValueAddress(), toAddr,
+                                 IsNotTake, IsInitialization);
+    optTemp->finishInitialization(SGF);
+    return RValue(SGF, {optTemp->getManagedAddress()}, subType.getASTType());
+  }
+
+  if (subType.isLoadable(SGF.F)) {
+    ManagedValue mv = SGF.emitRValue(subExpr).getAsSingleValue(SGF, subExpr);
+    if (mv.getType().isTrivial(SGF.F))
+      return RValue(SGF, {mv}, subType.getASTType());
+    mv = SGF.B.createExplicitCopyValue(E, mv);
+    return RValue(SGF, {mv}, subType.getASTType());
+  }
+
+  // If we aren't loadable, then create a temporary initialization and
+  // explicit_copy_addr into that.
+  std::unique_ptr<TemporaryInitialization> optTemp;
+  optTemp = SGF.emitTemporary(E, SGF.getTypeLowering(subType));
+  SILValue toAddr = optTemp->getAddressForInPlaceInitialization(SGF, E);
+  assert(!isa<LValueType>(E->getType()->getCanonicalType()) &&
+         "Shouldn't see an lvalue type here");
+
+  ManagedValue mv =
+      SGF.emitRValue(subExpr, SGFContext(SGFContext::AllowImmediatePlusZero))
+          .getAsSingleValue(SGF, subExpr);
+  assert(mv.getType().isAddress());
+  SGF.B.createExplicitCopyAddr(subExpr, mv.getValue(), toAddr, IsNotTake,
+                               IsInitialization);
+  optTemp->finishInitialization(SGF);
+  return RValue(SGF, {optTemp->getManagedAddress()}, subType.getASTType());
+}
+
 RValue RValueEmitter::visitMacroExpansionExpr(MacroExpansionExpr *E,
                                               SGFContext C) {
   if (auto *rewritten = E->getRewritten()) {

lib/SILGen/SILGenLValue.cpp

@@ -334,6 +334,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenLValue
                                      LValueOptions options);
   LValue visitMoveExpr(MoveExpr *e, SGFAccessKind accessKind,
                        LValueOptions options);
+  LValue visitCopyExpr(CopyExpr *e, SGFAccessKind accessKind,
+                       LValueOptions options);
   LValue visitABISafeConversionExpr(ABISafeConversionExpr *e,
                                     SGFAccessKind accessKind,
                                     LValueOptions options);
@@ -4033,6 +4035,30 @@ LValue SILGenLValue::visitMoveExpr(MoveExpr *e, SGFAccessKind accessKind,
                           toAddr->getType().getASTType());
 }
 
+LValue SILGenLValue::visitCopyExpr(CopyExpr *e, SGFAccessKind accessKind,
+                                   LValueOptions options) {
+  // Do formal evaluation of the base l-value.
+  LValue baseLV = visitRec(e->getSubExpr(), SGFAccessKind::BorrowedAddressRead,
+                           options.forComputedBaseLValue());
+
+  ManagedValue addr = SGF.emitAddressOfLValue(e, std::move(baseLV));
+
+  // Now create the temporary and copy our value into there using an explicit
+  // copy_value. This ensures that the rest of the move checker views this as a
+  // liveness requiring use rather than a copy that must be eliminated.
+  auto temp =
+      SGF.emitFormalAccessTemporary(e, SGF.F.getTypeLowering(addr.getType()));
+  auto toAddr = temp->getAddressForInPlaceInitialization(SGF, e);
+  SGF.B.createExplicitCopyAddr(e, addr.getValue(), toAddr, IsNotTake,
+                               IsInitialization);
+  temp->finishInitialization(SGF);
+
+  // Now return the temporary in a value component.
+  return LValue::forValue(SGFAccessKind::BorrowedAddressRead,
+                          temp->getManagedAddress(),
+                          toAddr->getType().getASTType());
+}
+
 LValue SILGenLValue::visitABISafeConversionExpr(ABISafeConversionExpr *e,
                                     SGFAccessKind accessKind,
                                     LValueOptions options) {

lib/Sema/CSApply.cpp

@@ -3525,6 +3525,27 @@ namespace {
       return expr;
     }
 
+    Expr *visitCopyExpr(CopyExpr *expr) {
+      auto toType = simplifyType(cs.getType(expr));
+      cs.setType(expr, toType);
+
+      auto *subExpr = expr->getSubExpr();
+      auto type = simplifyType(cs.getType(subExpr));
+
+      // Let's load the value associated with this try.
+      if (type->hasLValueType()) {
+        subExpr = coerceToType(subExpr, type->getRValueType(),
+                               cs.getConstraintLocator(subExpr));
+
+        if (!subExpr)
+          return nullptr;
+      }
+
+      expr->setSubExpr(subExpr);
+
+      return expr;
+    }
+
     Expr *visitAnyTryExpr(AnyTryExpr *expr) {
       auto *subExpr = expr->getSubExpr();
       auto type = simplifyType(cs.getType(subExpr));

lib/Sema/CSGen.cpp

@@ -1858,6 +1858,16 @@ namespace {
       return CS.getType(expr->getSubExpr());
     }
 
+    Type visitCopyExpr(CopyExpr *expr) {
+      auto valueTy = CS.createTypeVariable(CS.getConstraintLocator(expr),
+                                           TVO_PrefersSubtypeBinding |
+                                               TVO_CanBindToNoEscape);
+      CS.addConstraint(ConstraintKind::Equal, valueTy,
+                       CS.getType(expr->getSubExpr()),
+                       CS.getConstraintLocator(expr));
+      return valueTy;
+    }
+
     Type visitAnyTryExpr(AnyTryExpr *expr) {
       return CS.getType(expr->getSubExpr());
     }

lib/Sema/MiscDiagnostics.cpp

@@ -344,6 +344,12 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
         checkMoveExpr(moveExpr);
       }
 
+      // Diagnose copy expression uses where the sub expression is not a declref
+      // expr.
+      if (auto *copyExpr = dyn_cast<CopyExpr>(E)) {
+        checkCopyExpr(copyExpr);
+      }
+
       // Diagnose move expression uses where the sub expression is not a declref expr
       if (auto *borrowExpr = dyn_cast<BorrowExpr>(E)) {
         checkBorrowExpr(borrowExpr);
@@ -422,6 +428,26 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       }
     }
 
+    void checkCopyExpr(CopyExpr *copyExpr) {
+      // Do not allow for copy_expr to be used with pure move only types. We
+      // /do/ allow it to be used with no implicit copy types though.
+      if (copyExpr->getType()->isPureMoveOnly()) {
+        Ctx.Diags.diagnose(
+            copyExpr->getLoc(),
+            diag::copy_expression_cannot_be_used_with_noncopyable_types);
+      }
+
+      // We only allow for copy_expr to be applied directly to lvalues. We do
+      // not allow currently for it to be applied to fields.
+      auto *subExpr = copyExpr->getSubExpr();
+      if (auto *li = dyn_cast<LoadExpr>(subExpr))
+        subExpr = li->getSubExpr();
+      if (!isa<DeclRefExpr>(subExpr)) {
+        Ctx.Diags.diagnose(copyExpr->getLoc(),
+                           diag::copy_expression_not_passed_lvalue);
+      }
+    }
+
     void checkBorrowExpr(BorrowExpr *borrowExpr) {
       // Allow for a chain of member_ref exprs that end in a decl_ref expr.
       auto *subExpr = borrowExpr->getSubExpr();

test/IDE/copy_expr.swift

@@ -0,0 +1,7 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t
+
+func test(myParam: Int) {
+  copy #^COPY^#
+  // COPY: Decl[LocalVar]/Local:               myParam[#Int#]; name=myParam
+}