Implement .use keyword as an alias of clone

Author: spastorino

compiler/rustc_ast/src/ast.rs

@@ -1357,6 +1357,7 @@ impl Expr {
             // Never need parens
             ExprKind::Array(_)
             | ExprKind::Await(..)
+            | ExprKind::Use(..)
             | ExprKind::Block(..)
             | ExprKind::Call(..)
             | ExprKind::ConstBlock(_)
@@ -1536,6 +1537,8 @@ pub enum ExprKind {
     Gen(CaptureBy, P<Block>, GenBlockKind, Span),
     /// An await expression (`my_future.await`). Span is of await keyword.
     Await(P<Expr>, Span),
+    /// A use expression (`x.use`). Span is of use keyword.
+    Use(P<Expr>, Span),
 
     /// A try block (`try { ... }`).
     TryBlock(P<Block>),

compiler/rustc_ast/src/mut_visit.rs

@@ -1713,6 +1713,10 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             vis.visit_expr(expr);
             vis.visit_span(await_kw_span);
         }
+        ExprKind::Use(expr, use_kw_span) => {
+            vis.visit_expr(expr);
+            vis.visit_span(use_kw_span);
+        }
         ExprKind::Assign(el, er, span) => {
             vis.visit_expr(el);
             vis.visit_expr(er);

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, _)
+            | Use(e, _)
             | Binary(_, e, _)
             | Call(e, _)
             | Cast(e, _)
@@ -224,6 +225,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
             | Lit(_)
             | Type(_, _)
             | Await(_, _)
+            | Use(_, _)
             | Field(_, _)
             | Index(_, _, _)
             | Underscore

compiler/rustc_ast/src/visit.rs

@@ -1175,6 +1175,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) -> V
         }
         ExprKind::Gen(_capt, body, _kind, _decl_span) => try_visit!(visitor.visit_block(body)),
         ExprKind::Await(expr, _span) => try_visit!(visitor.visit_expr(expr)),
+        ExprKind::Use(expr, _span) => try_visit!(visitor.visit_expr(expr)),
         ExprKind::Assign(lhs, rhs, _span) => {
             try_visit!(visitor.visit_expr(lhs));
             try_visit!(visitor.visit_expr(rhs));

compiler/rustc_ast_lowering/messages.ftl

@@ -59,6 +59,8 @@ ast_lowering_default_field_in_tuple = default fields are not supported in tuple
 ast_lowering_does_not_support_modifiers =
     the `{$class_name}` register class does not support template modifiers
 
+ast_lowering_ergonomic_clones = ergonomic clones is experimental
+
 ast_lowering_extra_double_dot =
     `..` can only be used once per {$ctx} pattern
     .label = can only be used once per {$ctx} pattern

compiler/rustc_ast_lowering/src/expr.rs

@@ -229,6 +229,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     },
                 ),
                 ExprKind::Await(expr, await_kw_span) => self.lower_expr_await(*await_kw_span, expr),
+                ExprKind::Use(expr, use_kw_span) => {
+                    if !self.tcx.features().ergonomic_clones() {
+                        rustc_session::parse::feature_err(
+                            &self.tcx.sess,
+                            sym::ergonomic_clones,
+                            *use_kw_span,
+                            fluent_generated::ast_lowering_ergonomic_clones,
+                        )
+                        .emit();
+                    }
+                    self.lower_expr_use(*use_kw_span, expr)
+                }
                 ExprKind::Closure(box Closure {
                     binder,
                     capture_clause,
@@ -1033,6 +1045,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
         )
     }
 
+    /// Desugar `<expr>.use` into:
+    /// ```ignore (pseudo-rust)
+    /// <expr>.clone()
+    /// ```
+    fn lower_expr_use(&mut self, use_kw_span: Span, expr: &Expr) -> hir::ExprKind<'hir> {
+        let expr = self.lower_expr(expr);
+        let span = self.mark_span_with_reason(DesugaringKind::Use, use_kw_span, None);
+
+        hir::ExprKind::Use(expr, span)
+    }
+
     fn lower_expr_closure(
         &mut self,
         binder: &ClosureBinder,

compiler/rustc_ast_passes/messages.ftl

@@ -154,6 +154,9 @@ ast_passes_inherent_cannot_be = inherent impls cannot be {$annotation}
     .type = inherent impl for this type
     .only_trait = only trait implementations may be annotated with {$annotation}
 
+ast_passes_invalid_use_feature_disabled = Invalid `.use` with ergonomic_clones disabled
+    .note = enable ergonomic_clones feature
+
 ast_passes_item_invalid_safety = items outside of `unsafe extern {"{ }"}` cannot be declared with `safe` safety qualifier
     .suggestion = remove safe from this item
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -812,6 +812,21 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
         self.walk_ty(ty)
     }
 
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        if let ExprKind::Use(_, span) = expr.kind {
+            if !self.features.ergonomic_clones() {
+                self.sess
+                    .create_feature_err(
+                        errors::InvalidUseFeatureDisabled { span },
+                        sym::ergonomic_clones,
+                    )
+                    .emit();
+            }
+        }
+
+        visit::walk_expr(self, expr);
+    }
+
     fn visit_item(&mut self, item: &'a Item) {
         if item.attrs.iter().any(|attr| attr.is_proc_macro_attr()) {
             self.has_proc_macro_decls = true;

compiler/rustc_ast_passes/src/errors.rs

@@ -230,6 +230,14 @@ pub(crate) struct InvalidSafetyOnBareFn {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_passes_invalid_use_feature_disabled)]
+#[note]
+pub(crate) struct InvalidUseFeatureDisabled {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_passes_unsafe_static)]
 pub(crate) struct UnsafeStatic {

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

@@ -571,6 +571,14 @@ impl<'a> State<'a> {
                 );
                 self.word(".await");
             }
+            ast::ExprKind::Use(expr, _) => {
+                self.print_expr_cond_paren(
+                    expr,
+                    expr.precedence() < ExprPrecedence::Unambiguous,
+                    fixup,
+                );
+                self.word(".use");
+            }
             ast::ExprKind::Assign(lhs, rhs, _) => {
                 self.print_expr_cond_paren(
                     lhs,