Rename MoveExpr -> ConsumeExpr to reflect the final name.

NFC.

Author: gottesmm

include/swift/AST/DiagnosticsSema.def

@@ -6992,7 +6992,7 @@ ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
 
 ERROR(moveOnly_not_allowed_here,none,
       "'moveOnly' only applies to structs or enums", ())
-ERROR(move_expression_not_passed_lvalue,none,
+ERROR(consume_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", ())

include/swift/AST/Expr.h

@@ -2050,31 +2050,34 @@ class AwaitExpr final : public IdentityExpr {
   }
 };
 
-/// MoveExpr - A 'move' surrounding an lvalue expression marking the lvalue as
-/// needing to be moved.
+/// ConsumeExpr - A 'consume' surrounding an lvalue expression marking the
+/// lvalue as needing to be moved.
 ///
 /// getSemanticsProvidingExpr() looks through this because it doesn't
 /// provide the value and only very specific clients care where the
 /// 'move' was written.
-class MoveExpr final : public IdentityExpr {
-  SourceLoc MoveLoc;
+class ConsumeExpr final : public IdentityExpr {
+  SourceLoc ConsumeLoc;
 
 public:
-  MoveExpr(SourceLoc moveLoc, Expr *sub, Type type = Type(),
-           bool implicit = false)
-      : IdentityExpr(ExprKind::Move, sub, type, implicit), MoveLoc(moveLoc) {}
+  ConsumeExpr(SourceLoc consumeLoc, Expr *sub, Type type = Type(),
+              bool implicit = false)
+      : IdentityExpr(ExprKind::Consume, sub, type, implicit),
+        ConsumeLoc(consumeLoc) {}
 
-  static MoveExpr *createImplicit(ASTContext &ctx, SourceLoc moveLoc, Expr *sub,
-                                  Type type = Type()) {
-    return new (ctx) MoveExpr(moveLoc, sub, type, /*implicit=*/true);
+  static ConsumeExpr *createImplicit(ASTContext &ctx, SourceLoc moveLoc,
+                                     Expr *sub, Type type = Type()) {
+    return new (ctx) ConsumeExpr(moveLoc, sub, type, /*implicit=*/true);
   }
 
-  SourceLoc getLoc() const { return MoveLoc; }
+  SourceLoc getLoc() const { return ConsumeLoc; }
 
-  SourceLoc getStartLoc() const { return MoveLoc; }
+  SourceLoc getStartLoc() const { return ConsumeLoc; }
   SourceLoc getEndLoc() const { return getSubExpr()->getEndLoc(); }
 
-  static bool classof(const Expr *e) { return e->getKind() == ExprKind::Move; }
+  static bool classof(const Expr *e) {
+    return e->getKind() == ExprKind::Consume;
+  }
 };
 
 /// CopyExpr - A 'copy' surrounding an lvalue expression marking the lvalue as

include/swift/AST/ExprNodes.def

@@ -107,7 +107,7 @@ ABSTRACT_EXPR(Identity, Expr)
   EXPR(Paren, IdentityExpr)
   EXPR(DotSelf, IdentityExpr)
   EXPR(Await, IdentityExpr)
-  EXPR(Move, IdentityExpr)
+  EXPR(Consume, IdentityExpr)
   EXPR(Borrow, IdentityExpr)
   EXPR(UnresolvedMemberChainResult, IdentityExpr)
   EXPR_RANGE(Identity, Paren, UnresolvedMemberChainResult)

lib/AST/ASTDumper.cpp

@@ -2194,8 +2194,8 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
-  void visitMoveExpr(MoveExpr *E) {
-    printCommon(E, "move_expr");
+  void visitConsumeExpr(ConsumeExpr *E) {
+    printCommon(E, "consume_expr");
     OS << '\n';
     printRec(E->getSubExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';

lib/AST/ASTPrinter.cpp

@@ -4995,8 +4995,8 @@ void PrintAST::visitAwaitExpr(AwaitExpr *expr) {
   visit(expr->getSubExpr());
 }
 
-void PrintAST::visitMoveExpr(MoveExpr *expr) {
-  Printer << "move ";
+void PrintAST::visitConsumeExpr(ConsumeExpr *expr) {
+  Printer << "consume ";
   visit(expr->getSubExpr());
 }
 

lib/AST/Expr.cpp

@@ -370,7 +370,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(UnresolvedMemberChainResult, getSubExpr);
   PASS_THROUGH_REFERENCE(DotSelf, getSubExpr);
   PASS_THROUGH_REFERENCE(Await, getSubExpr);
-  PASS_THROUGH_REFERENCE(Move, getSubExpr);
+  PASS_THROUGH_REFERENCE(Consume, getSubExpr);
   PASS_THROUGH_REFERENCE(Copy, getSubExpr);
   PASS_THROUGH_REFERENCE(Borrow, getSubExpr);
   PASS_THROUGH_REFERENCE(Try, getSubExpr);
@@ -743,7 +743,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
     return true;
 
   case ExprKind::Await:
-  case ExprKind::Move:
+  case ExprKind::Consume:
   case ExprKind::Copy:
   case ExprKind::Borrow:
   case ExprKind::Try:
@@ -936,7 +936,7 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::Sequence:
   case ExprKind::Paren:
   case ExprKind::Await:
-  case ExprKind::Move:
+  case ExprKind::Consume:
   case ExprKind::Copy:
   case ExprKind::Borrow:
   case ExprKind::UnresolvedMemberChainResult:

lib/Parse/ParseExpr.cpp

@@ -418,7 +418,7 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
     ParserResult<Expr> sub =
         parseExprSequenceElement(diag::expected_expr_after_move, isExprBasic);
     if (!sub.isNull()) {
-      sub = makeParserResult(new (Context) MoveExpr(consumeLoc, sub.get()));
+      sub = makeParserResult(new (Context) ConsumeExpr(consumeLoc, sub.get()));
     }
     return sub;
   }
@@ -448,7 +448,7 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
       ParserResult<Expr> sub =
           parseExprSequenceElement(diag::expected_expr_after_move, isExprBasic);
       if (!sub.hasCodeCompletion() && !sub.isNull()) {
-        sub = makeParserResult(new (Context) MoveExpr(awaitLoc, sub.get()));
+        sub = makeParserResult(new (Context) ConsumeExpr(awaitLoc, sub.get()));
       }
       return sub;
     }

lib/SILGen/SILGenExpr.cpp

@@ -551,7 +551,7 @@ namespace {
         LinearFunctionExtractOriginalExpr *E, SGFContext C);
     RValue visitLinearToDifferentiableFunctionExpr(
         LinearToDifferentiableFunctionExpr *E, SGFContext C);
-    RValue visitMoveExpr(MoveExpr *E, SGFContext C);
+    RValue visitConsumeExpr(ConsumeExpr *E, SGFContext C);
     RValue visitCopyExpr(CopyExpr *E, SGFContext C);
     RValue visitMacroExpansionExpr(MacroExpansionExpr *E, SGFContext C);
   };
@@ -6115,7 +6115,7 @@ RValue RValueEmitter::visitErrorExpr(ErrorExpr *E, SGFContext C) {
   llvm::report_fatal_error("Found an ErrorExpr but didn't emit an error?");
 }
 
-RValue RValueEmitter::visitMoveExpr(MoveExpr *E, SGFContext C) {
+RValue RValueEmitter::visitConsumeExpr(ConsumeExpr *E, SGFContext C) {
   auto *subExpr = cast<DeclRefExpr>(E->getSubExpr());
   auto subASTType = subExpr->getType()->getCanonicalType();
 

lib/SILGen/SILGenLValue.cpp

@@ -332,8 +332,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenLValue
   LValue visitKeyPathApplicationExpr(KeyPathApplicationExpr *e,
                                      SGFAccessKind accessKind,
                                      LValueOptions options);
-  LValue visitMoveExpr(MoveExpr *e, SGFAccessKind accessKind,
-                       LValueOptions options);
+  LValue visitConsumeExpr(ConsumeExpr *e, SGFAccessKind accessKind,
+                          LValueOptions options);
   LValue visitCopyExpr(CopyExpr *e, SGFAccessKind accessKind,
                        LValueOptions options);
   LValue visitABISafeConversionExpr(ABISafeConversionExpr *e,
@@ -4004,8 +4004,8 @@ LValue SILGenLValue::visitInOutExpr(InOutExpr *e, SGFAccessKind accessKind,
   return visitRec(e->getSubExpr(), accessKind, options);
 }
 
-LValue SILGenLValue::visitMoveExpr(MoveExpr *e, SGFAccessKind accessKind,
-                                   LValueOptions options) {
+LValue SILGenLValue::visitConsumeExpr(ConsumeExpr *e, SGFAccessKind accessKind,
+                                      LValueOptions options) {
   // Do formal evaluation of the base l-value.
   LValue baseLV = visitRec(e->getSubExpr(), SGFAccessKind::ReadWrite,
                            options.forComputedBaseLValue());

lib/Sema/MiscDiagnostics.cpp

@@ -340,8 +340,8 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
 
       // Diagnose move expression uses where the sub expression is not a declref
       // expr.
-      if (auto *moveExpr = dyn_cast<MoveExpr>(E)) {
-        checkMoveExpr(moveExpr);
+      if (auto *consumeExpr = dyn_cast<ConsumeExpr>(E)) {
+        checkConsumeExpr(consumeExpr);
       }
 
       // Diagnose copy expression uses where the sub expression is not a declref
@@ -421,10 +421,10 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       }
     }
 
-    void checkMoveExpr(MoveExpr *moveExpr) {
-      if (!isa<DeclRefExpr>(moveExpr->getSubExpr())) {
-        Ctx.Diags.diagnose(moveExpr->getLoc(),
-                           diag::move_expression_not_passed_lvalue);
+    void checkConsumeExpr(ConsumeExpr *consumeExpr) {
+      if (!isa<DeclRefExpr>(consumeExpr->getSubExpr())) {
+        Ctx.Diags.diagnose(consumeExpr->getLoc(),
+                           diag::consume_expression_not_passed_lvalue);
       }
     }