add move(expr) syntax

Author: TaKO8Ki

compiler/rustc_ast/src/ast.rs

@@ -1595,6 +1595,7 @@ impl Expr {
             // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
             // but we need to print `(let _ = a) < b` as-is with parens.
             | ExprKind::Let(..)
+            | ExprKind::Move(..)
             | ExprKind::Unary(..) => ExprPrecedence::Prefix,
 
             // Need parens if and only if there are prefix attributes.
@@ -1764,6 +1765,8 @@ pub enum ExprKind {
     Binary(BinOp, Box<Expr>, Box<Expr>),
     /// A unary operation (e.g., `!x`, `*x`).
     Unary(UnOp, Box<Expr>),
+    /// A `move(expr)` expression.
+    Move(Box<Expr>, Span),
     /// A literal (e.g., `1`, `"foo"`).
     Lit(token::Lit),
     /// A cast (e.g., `foo as f64`).

compiler/rustc_ast/src/util/classify.rs

@@ -108,6 +108,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
             Assign(e, _, _)
             | AssignOp(_, e, _)
             | Await(e, _)
+            | Move(e, _)
             | Use(e, _)
             | Binary(_, e, _)
             | Call(e, _)
@@ -183,6 +184,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
             | Ret(Some(e))
             | Unary(_, e)
             | Yeet(Some(e))
+            | Move(e, _)
             | Become(e) => {
                 expr = e;
             }

compiler/rustc_ast/src/visit.rs

@@ -1023,7 +1023,9 @@ macro_rules! common_visitor_and_walkers {
                     visit_visitable!($($mut)? vis, block, opt_label),
                 ExprKind::Gen(capt, body, kind, decl_span) =>
                     visit_visitable!($($mut)? vis, capt, body, kind, decl_span),
-                ExprKind::Await(expr, span) | ExprKind::Use(expr, span) =>
+                ExprKind::Await(expr, span)
+                | ExprKind::Move(expr, span)
+                | ExprKind::Use(expr, span) =>
                     visit_visitable!($($mut)? vis, expr, span),
                 ExprKind::Assign(lhs, rhs, span) =>
                     visit_visitable!($($mut)? vis, lhs, rhs, span),

compiler/rustc_ast_lowering/src/errors.rs

@@ -136,6 +136,13 @@ pub(crate) struct ClosureCannotBeStatic {
     pub fn_decl_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("`move(expr)` is only supported in plain closures")]
+pub(crate) struct MoveExprOnlyInPlainClosures {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("functional record updates are not allowed in destructuring assignments")]
 pub(crate) struct FunctionalRecordUpdateDestructuringAssignment {

compiler/rustc_ast_lowering/src/expr.rs

@@ -20,8 +20,8 @@ use visit::{Visitor, walk_expr};
 use super::errors::{
     AsyncCoroutinesNotSupported, AwaitOnlyInAsyncFnAndBlocks, ClosureCannotBeStatic,
     CoroutineTooManyParameters, FunctionalRecordUpdateDestructuringAssignment,
-    InclusiveRangeWithNoEnd, MatchArmWithNoBody, NeverPatternWithBody, NeverPatternWithGuard,
-    UnderscoreExprLhsAssign,
+    InclusiveRangeWithNoEnd, MatchArmWithNoBody, MoveExprOnlyInPlainClosures, NeverPatternWithBody,
+    NeverPatternWithGuard, UnderscoreExprLhsAssign,
 };
 use super::{
     GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt,
@@ -212,6 +212,18 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                     },
                 ),
                 ExprKind::Await(expr, await_kw_span) => self.lower_expr_await(*await_kw_span, expr),
+                ExprKind::Move(_, move_kw_span) => {
+                    if !self.tcx.features().move_expr() {
+                        return self.expr_err(
+                            *move_kw_span,
+                            self.dcx().span_delayed_bug(*move_kw_span, "invalid move(expr)"),
+                        );
+                    }
+                    self.dcx().emit_err(MoveExprOnlyInPlainClosures { span: *move_kw_span });
+                    hir::ExprKind::Err(
+                        self.dcx().span_delayed_bug(*move_kw_span, "invalid move(expr)"),
+                    )
+                }
                 ExprKind::Use(expr, use_kw_span) => self.lower_expr_use(*use_kw_span, expr),
                 ExprKind::Closure(box Closure {
                     binder,

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -352,6 +352,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 }
                 _ => (),
             },
+            ast::ExprKind::Move(_, move_kw_span) => {
+                gate!(&self, move_expr, move_kw_span, "`move(expr)` syntax is experimental");
+            }
             _ => {}
         }
         visit::walk_expr(self, e)

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -630,6 +630,11 @@ impl<'a> State<'a> {
                 );
                 self.word(".await");
             }
+            ast::ExprKind::Move(expr, _) => {
+                self.word("move(");
+                self.print_expr(expr, FixupContext::default());
+                self.word(")");
+            }
             ast::ExprKind::Use(expr, _) => {
                 self.print_expr_cond_paren(
                     expr,

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -248,6 +248,9 @@ impl<'cx, 'a> Context<'cx, 'a> {
                     self.manage_cond_expr(arg);
                 }
             }
+            ExprKind::Move(local_expr, _) => {
+                self.manage_cond_expr(local_expr);
+            }
             ExprKind::Path(_, Path { segments, .. }) if let [path_segment] = &segments[..] => {
                 let path_ident = path_segment.ident;
                 self.manage_initial_capture(expr, path_ident);

compiler/rustc_parse/src/parser/expr.rs

@@ -563,6 +563,12 @@ impl<'a> Parser<'a> {
             token::Ident(..) if this.token.is_keyword(kw::Box) => {
                 make_it!(this, attrs, |this, _| this.parse_expr_box(lo))
             }
+            token::Ident(..)
+                if this.token.is_keyword(kw::Move)
+                    && this.look_ahead(1, |t| *t == token::OpenParen) =>
+            {
+                make_it!(this, attrs, |this, _| this.parse_expr_move(lo))
+            }
             token::Ident(..) if this.may_recover() && this.is_mistaken_not_ident_negation() => {
                 make_it!(this, attrs, |this, _| this.recover_not_expr(lo))
             }
@@ -606,6 +612,16 @@ impl<'a> Parser<'a> {
         Ok((span, ExprKind::Err(guar)))
     }
 
+    fn parse_expr_move(&mut self, move_kw: Span) -> PResult<'a, (Span, ExprKind)> {
+        self.bump();
+        self.psess.gated_spans.gate(sym::move_expr, move_kw);
+        self.expect(exp!(OpenParen))?;
+        let expr = self.parse_expr()?;
+        self.expect(exp!(CloseParen))?;
+        let span = move_kw.to(self.prev_token.span);
+        Ok((span, ExprKind::Move(expr, move_kw)))
+    }
+
     fn is_mistaken_not_ident_negation(&self) -> bool {
         let token_cannot_continue_expr = |t: &Token| match t.uninterpolate().kind {
             // These tokens can start an expression after `!`, but
@@ -4387,6 +4403,7 @@ impl MutVisitor for CondChecker<'_> {
             }
             ExprKind::Unary(_, _)
             | ExprKind::Await(_, _)
+            | ExprKind::Move(_, _)
             | ExprKind::Use(_, _)
             | ExprKind::AssignOp(_, _, _)
             | ExprKind::Range(_, _, _)

compiler/rustc_passes/src/input_stats.rs

@@ -657,7 +657,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
             (self, e, e.kind, None, ast, Expr, ExprKind),
             [
                 Array, ConstBlock, Call, MethodCall, Tup, Binary, Unary, Lit, Cast, Type, Let,
-                If, While, ForLoop, Loop, Match, Closure, Block, Await, Use, TryBlock, Assign,
+                If, While, ForLoop, Loop, Match, Closure, Block, Await, Move, Use, TryBlock, Assign,
                 AssignOp, Field, Index, Range, Underscore, Path, AddrOf, Break, Continue, Ret,
                 InlineAsm, FormatArgs, OffsetOf, MacCall, Struct, Repeat, Paren, Try, Yield, Yeet,
                 Become, IncludedBytes, Gen, UnsafeBinderCast, Err, Dummy