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

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.
+///
+/// getSemanticsProvidingExpr() looks through this because it doesn't
+/// provide the value and only very specific clients care where the
+/// 'move' was written.
+class CopyExpr final : public IdentityExpr {
+  SourceLoc CopyLoc;
+
+public:
+  CopyExpr(SourceLoc copyLoc, Expr *sub, Type type = Type(),
+           bool implicit = false)
+      : IdentityExpr(ExprKind::Copy, sub, type, implicit), 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; }
+
+  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

@@ -108,6 +108,7 @@ ABSTRACT_EXPR(Identity, Expr)
   EXPR(DotSelf, IdentityExpr)
   EXPR(Await, IdentityExpr)
   EXPR(Move, IdentityExpr)
+  EXPR(Copy, IdentityExpr)
   EXPR(Borrow, IdentityExpr)
   EXPR(UnresolvedMemberChainResult, IdentityExpr)
   EXPR_RANGE(Identity, Paren, UnresolvedMemberChainResult)

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/Expr.cpp

@@ -372,6 +372,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 +745,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 +938,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) &&
+      !peekToken().isAtStartOfLine()) {
+    Tok.setKind(tok::contextual_keyword);
+
+    SourceLoc copyLoc = consumeToken();
+    ParserResult<Expr> sub =
+        parseExprSequenceElement(diag::expected_expr_after_copy, isExprBasic);
+    if (!sub.hasCodeCompletion() && !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,38 @@ RValue RValueEmitter::visitMoveExpr(MoveExpr *E, SGFContext C) {
   return RValue(SGF, {optTemp->getManagedAddress()}, subType.getASTType());
 }
 
+RValue RValueEmitter::visitCopyExpr(CopyExpr *E, SGFContext C) {
+  auto *subExpr = cast<DeclRefExpr>(E->getSubExpr());
+  auto subASTType = subExpr->getType()->getCanonicalType();
+
+  auto subType = SGF.getLoweredType(subASTType);
+
+  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/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,23 @@ 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.
+      if (!isa<DeclRefExpr>(copyExpr->getSubExpr())) {
+        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/Parse/copy_expr.swift

@@ -0,0 +1,105 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking
+
+var global: Int = 5
+func testGlobal() {
+    let _ = copy global
+}
+
+func testLet() {
+    let t = String()
+    let _ = copy t
+}
+
+func testVar() {
+    var t = String()
+    t = String()
+    let _ = copy t
+}
+
+func copy() {}
+func copy(_: String) {}
+func copy(_: String, _: Int) {}
+func copy(x: String, y: Int) {}
+
+// Ensure that we can still call a function named copy.
+
+func useCopyFunc() {
+    var s = String()
+    var i = global
+
+    copy()
+    copy(s)
+    copy(i) // expected-error{{cannot convert value of type 'Int' to expected argument type 'String'}}
+    copy(s, i)
+    copy(i, s) // expected-error{{unnamed argument #2 must precede unnamed argument #1}}
+    copy(x: s, y: i)
+    copy(y: i, x: s) // expected-error{{argument 'x' must precede argument 'y'}}
+}
+
+// Ensure that we can still use a variable named copy.
+
+func useCopyVar(copy: inout String) {
+    let s = copy
+    copy = s
+
+    // We can copy from a variable named `copy`
+    let t = copy copy
+    copy = t
+
+    // We can do member access and subscript a variable named `copy`
+    let i = copy.startIndex
+    let _ = copy[i]
+}
+
+@propertyWrapper
+struct FooWrapper<T> {
+    var value: T
+
+    init(wrappedValue: T) { value = wrappedValue }
+
+    var wrappedValue: T {
+        get { value }
+        nonmutating set {}
+    }
+    var projectedValue: T {
+        get { value }
+        nonmutating set {}
+    }
+}
+
+struct Foo {
+    @FooWrapper var wrapperTest: String
+
+    func copySelf() {
+        _ = copy self
+    }
+
+    func copyPropertyWrapper() {
+        // Make sure that we can parse.
+        _ = copy wrapperTest // expected-error {{'copy' can only be applied to lvalues}}
+        _ = copy _wrapperTest // expected-error {{'copy' can only be applied to lvalues}}
+        _ = copy $wrapperTest // expected-error {{'copy' can only be applied to lvalues}}
+    }
+}
+
+func testParseCopyWithDollarIdentifier() {
+  class Klass {}
+  let f: (Klass) -> () = {
+    let _ = copy $0
+  }
+  _ = f
+}
+
+func testParseCopySelf() {
+  class Klass {
+    func test() {
+      let _ = copy self
+    }
+  }
+}
+
+func testForLoop() {
+  for copy in 0..<1024 {
+    _ = copy
+  }
+}