Auto merge of rust-lang#111773 - Jules-Bertholet:await-autoref, r=<try>

Perform autoref/autoderef on `.await`

This PR adds support for autoref/autoderef of the reciever of an `.await` (before calling `IntoFuture::into_future()`).

This PR is not ready to merge yet—the feature works, but diagnostics are regressed and clippy is broken. I would like to get some feedback on my current approach, before investing more effort into it.

Fixes rust-lang#111546.

Author: bors

compiler/rustc_ast_lowering/src/expr.rs

@@ -106,7 +106,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let receiver = self.lower_expr(receiver);
                     let args =
                         self.arena.alloc_from_iter(args.iter().map(|x| self.lower_expr_mut(x)));
-                    hir::ExprKind::MethodCall(hir_seg, receiver, args, self.lower_span(*span))
+                    hir::ExprKind::MethodCall(
+                        hir::MethodCallPath::Segment(hir_seg),
+                        receiver,
+                        args,
+                        self.lower_span(*span),
+                    )
                 }
                 ExprKind::Binary(binop, lhs, rhs) => {
                     let binop = self.lower_binop(*binop);
@@ -755,7 +760,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     /// Desugar `<expr>.await` into:
     /// ```ignore (pseudo-rust)
-    /// match ::std::future::IntoFuture::into_future(<expr>) {
+    /// match <expr>.<::core::future::IntoFuture::into_future>() {
     ///     mut __awaitee => loop {
     ///         match unsafe { ::std::future::Future::poll(
     ///             <::std::pin::Pin>::new_unchecked(&mut __awaitee),
@@ -915,13 +920,19 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // mut __awaitee => loop { ... }
         let awaitee_arm = self.arm(awaitee_pat, loop_expr);
 
-        // `match ::std::future::IntoFuture::into_future(<expr>) { ... }`
-        let into_future_expr = self.expr_call_lang_item_fn(
+        // `<expr>.<::core::future::IntoFuture::into_future>()`
+        // This is special; it does auto(de)ref like a method call,
+        // but name-resolves only to the `into_future_into_future`
+        // lang item.
+        let into_future_expr = self.arena.alloc(self.expr(
             span,
-            hir::LangItem::IntoFutureIntoFuture,
-            arena_vec![self; expr],
-            Some(expr_hir_id),
-        );
+            hir::ExprKind::MethodCall(
+                hir::MethodCallPath::AwaitIntoFuture(await_kw_span),
+                self.arena.alloc(expr),
+                &[],
+                await_kw_span,
+            ),
+        ));
 
         // match <into_future_expr> {
         //     mut __awaitee => loop { .. }

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1388,7 +1388,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 }
 
                 if let hir::ExprKind::MethodCall(body_call, recv, ..) = ex.kind
-                    && body_call.ident.name == sym::next
+                    && body_call.ident().name == sym::next
                     && recv.span.source_equal(self.expr_span)
                 {
                     self.body_expr = Some(ex);
@@ -2324,11 +2324,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                         {
                             if let Some(call) = visitor.call
                                 && let hir::ExprKind::MethodCall(path, _, [], _) = call.kind
-                                && path.ident.name == sym::iter
+                                && path.ident().name == sym::iter
                                 && let Some(ty) = expr_ty
                             {
                                 err.span_suggestion_verbose(
-                                    path.ident.span,
+                                    path.ident().span,
                                     format!(
                                         "consider consuming the `{ty}` when turning it into an \
                                          `Iterator`",

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -881,7 +881,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                 && let Call(_, [expr]) = expr.kind
             {
                 match expr.kind {
-                    MethodCall(path_segment, _, _, span) => {
+                    MethodCall(hir::MethodCallPath::Segment(path_segment), _, _, span) => {
                         // We have `for _ in iter.read_only_iter()`, try to
                         // suggest `for _ in iter.mutable_iter()` instead.
                         let opt_suggestions = self
@@ -1033,7 +1033,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
             && let Some(Node::Expr(expr)) = hir.find_parent(*hir_id)
         {
             let mut cur_expr = expr;
-            while let ExprKind::MethodCall(path_segment, recv, _, _) = cur_expr.kind {
+            while let ExprKind::MethodCall(hir::MethodCallPath::Segment(path_segment), recv, _, _) = cur_expr.kind {
                 if path_segment.ident.name == sym::iter {
                     // check `_ty` has `iter_mut` method
                     let res = self

compiler/rustc_hir/src/hir.rs

@@ -1910,7 +1910,7 @@ impl Expr<'_> {
 
     pub fn method_ident(&self) -> Option<Ident> {
         match self.kind {
-            ExprKind::MethodCall(receiver_method, ..) => Some(receiver_method.ident),
+            ExprKind::MethodCall(receiver_method, ..) => Some(receiver_method.ident()),
             ExprKind::Unary(_, expr) | ExprKind::AddrOf(.., expr) => expr.method_ident(),
             _ => None,
         }
@@ -1943,6 +1943,48 @@ pub fn is_range_literal(expr: &Expr<'_>) -> bool {
     }
 }
 
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub enum MethodCallPath<'hir> {
+    Segment(&'hir PathSegment<'hir>),
+    // Used in the `.await` desugaring.
+    AwaitIntoFuture(Span),
+}
+
+impl<'hir> MethodCallPath<'hir> {
+    #[inline]
+    pub fn ident(self) -> Ident {
+        match self {
+            MethodCallPath::Segment(segment) => segment.ident,
+            MethodCallPath::AwaitIntoFuture(span) => Ident::new(sym::into_future, span),
+        }
+    }
+
+    #[inline]
+    pub fn span(self) -> Span {
+        match self {
+            MethodCallPath::Segment(segment) => segment.ident.span,
+            MethodCallPath::AwaitIntoFuture(span) => span,
+        }
+    }
+
+    #[inline]
+    pub fn opt_args<'a>(self) -> Option<&'a GenericArgs<'hir>> {
+        match self {
+            MethodCallPath::Segment(segment) => segment.args,
+            MethodCallPath::AwaitIntoFuture(_) => None,
+        }
+    }
+
+    #[inline]
+    pub fn args<'a>(self) -> &'a GenericArgs<'hir> {
+        const EMPTY: GenericArgs<'_> = GenericArgs::none();
+        match self {
+            MethodCallPath::Segment(segment) => segment.args(),
+            MethodCallPath::AwaitIntoFuture(_) => &EMPTY,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum ExprKind<'hir> {
     /// Allow anonymous constants from an inline `const` block
@@ -1958,8 +2000,13 @@ pub enum ExprKind<'hir> {
     Call(&'hir Expr<'hir>, &'hir [Expr<'hir>]),
     /// A method call (e.g., `x.foo::<'static, Bar, Baz>(a, b, c, d)`).
     ///
-    /// The `PathSegment` represents the method name and its generic arguments
-    /// (within the angle brackets).
+    /// The [`MethodCallPath`] is either:
+    ///
+    /// - a [`PathSegment`] that represents the method name and its generic arguments
+    /// (within the angle brackets), or
+    /// - `IntoFutureFn` that represents a call to `IntoFuture::into_future()`
+    /// from the `.await` desugaring.
+    ///
     /// The `&Expr` is the expression that evaluates
     /// to the object on which the method is being called on (the receiver),
     /// and the `&[Expr]` is the rest of the arguments.
@@ -1972,7 +2019,7 @@ pub enum ExprKind<'hir> {
     /// the `hir_id` of the `MethodCall` node itself.
     ///
     /// [`type_dependent_def_id`]: ../../rustc_middle/ty/struct.TypeckResults.html#method.type_dependent_def_id
-    MethodCall(&'hir PathSegment<'hir>, &'hir Expr<'hir>, &'hir [Expr<'hir>], Span),
+    MethodCall(MethodCallPath<'hir>, &'hir Expr<'hir>, &'hir [Expr<'hir>], Span),
     /// A tuple (e.g., `(a, b, c, d)`).
     Tup(&'hir [Expr<'hir>]),
     /// A binary operation (e.g., `a + b`, `a * b`).

compiler/rustc_hir/src/intravisit.rs

@@ -715,8 +715,10 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
             visitor.visit_expr(callee_expression);
             walk_list!(visitor, visit_expr, arguments);
         }
-        ExprKind::MethodCall(ref segment, receiver, arguments, _) => {
-            visitor.visit_path_segment(segment);
+        ExprKind::MethodCall(ref call_path, receiver, arguments, _) => {
+            if let &MethodCallPath::Segment(segment) = call_path {
+                visitor.visit_path_segment(segment);
+            }
             visitor.visit_expr(receiver);
             walk_list!(visitor, visit_expr, arguments);
         }

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -154,7 +154,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
         }
         Node::Expr(&Expr {
             kind:
-                ExprKind::MethodCall(segment, ..) | ExprKind::Path(QPath::TypeRelative(_, segment)),
+                ExprKind::MethodCall(hir::MethodCallPath::Segment(segment), ..) | ExprKind::Path(QPath::TypeRelative(_, segment)),
             ..
         }) => {
             let body_owner = tcx.hir().enclosing_body_owner(hir_id);

compiler/rustc_hir_pretty/src/lib.rs

@@ -1126,14 +1126,14 @@ impl<'a> State<'a> {
 
     fn print_expr_method_call(
         &mut self,
-        segment: &hir::PathSegment<'_>,
+        segment: hir::MethodCallPath<'_>,
         receiver: &hir::Expr<'_>,
         args: &[hir::Expr<'_>],
     ) {
         let base_args = args;
         self.print_expr_maybe_paren(&receiver, parser::PREC_POSTFIX);
         self.word(".");
-        self.print_ident(segment.ident);
+        self.print_ident(segment.ident());
 
         let generic_args = segment.args();
         if !generic_args.args.is_empty() || !generic_args.bindings.is_empty() {

compiler/rustc_hir_typeck/src/callee.rs

@@ -511,7 +511,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 call_expr,
                 callee_ty,
                 &pick,
-                segment,
+                hir::MethodCallPath::Segment(segment),
             );
             if pick.illegal_sized_bound.is_some() {
                 return;

compiler/rustc_hir_typeck/src/demand.rs

@@ -807,7 +807,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
 
         let Ok(pick) = self.lookup_probe_for_diagnostic(
-            path.ident,
+            path.ident(),
             self_ty,
             deref,
             probe::ProbeScope::TraitsInScope,
@@ -817,7 +817,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
         let in_scope_methods = self.probe_for_name_many(
             probe::Mode::MethodCall,
-            path.ident,
+            path.ident(),
             Some(expected),
             probe::IsSuggestion(true),
             self_ty,
@@ -829,7 +829,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let all_methods = self.probe_for_name_many(
             probe::Mode::MethodCall,
-            path.ident,
+            path.ident(),
             Some(expected),
             probe::IsSuggestion(true),
             self_ty,
@@ -871,9 +871,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         if suggestions.is_empty() {
             return;
         }
-        let mut path_span: MultiSpan = path.ident.span.into();
+        let mut path_span: MultiSpan = path.ident().span.into();
         path_span.push_span_label(
-            path.ident.span,
+            path.ident().span,
             with_no_trimmed_paths!(format!(
                 "refers to `{}`",
                 self.tcx.def_path_str(pick.item.def_id),
@@ -921,7 +921,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             path_span,
             format!(
                 "the `{}` call is resolved to the method in `{container}`, shadowing {tail}",
-                path.ident,
+                path.ident(),
             ),
         );
         if suggestions.len() > other_methods_in_scope.len() {
@@ -1109,7 +1109,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 else {
                     return;
                 };
-                maybe_emit_help(def_id, method.ident, args, CallableKind::Method)
+                maybe_emit_help(def_id, method.ident(), args, CallableKind::Method)
             }
             _ => return,
         }

compiler/rustc_hir_typeck/src/expr.rs

@@ -243,7 +243,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {}
             ExprKind::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
             ExprKind::MethodCall(segment, ..) => {
-                self.warn_if_unreachable(expr.hir_id, segment.ident.span, "call")
+                self.warn_if_unreachable(expr.hir_id, segment.ident().span, "call")
             }
             _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression"),
         }
@@ -1305,15 +1305,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn check_method_call(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
-        segment: &hir::PathSegment<'_>,
+        segment: hir::MethodCallPath<'_>,
         rcvr: &'tcx hir::Expr<'tcx>,
         args: &'tcx [hir::Expr<'tcx>],
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
         let rcvr_t = self.check_expr(&rcvr);
         // no need to check for bot/err -- callee does that
         let rcvr_t = self.structurally_resolve_type(rcvr.span, rcvr_t);
-        let span = segment.ident.span;
+        let span = segment.ident().span;
 
         let method = match self.lookup_method(rcvr_t, segment, span, expr, rcvr, args) {
             Ok(method) => {
@@ -1325,11 +1325,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Ok(method)
             }
             Err(error) => {
-                if segment.ident.name != kw::Empty {
+                if segment.ident().name != kw::Empty {
                     if let Some(mut err) = self.report_method_error(
                         span,
                         rcvr_t,
-                        segment.ident,
+                        segment.ident(),
                         SelfSource::MethodCall(rcvr),
                         error,
                         Some(args),

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1038,9 +1038,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return;
         }
 
-        let mut sp = MultiSpan::from_span(path_segment.ident.span);
+        let mut sp = MultiSpan::from_span(path_segment.ident().span);
         sp.push_span_label(
-            path_segment.ident.span,
+            path_segment.ident().span,
             format!(
                 "this call modifies {} in-place",
                 match rcvr.kind {
@@ -1054,14 +1054,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
 
         let modifies_rcvr_note =
-            format!("method `{}` modifies its receiver in-place", path_segment.ident);
+            format!("method `{}` modifies its receiver in-place", path_segment.ident());
         if rcvr_has_the_expected_type {
             sp.push_span_label(
                 rcvr.span,
                 "you probably want to use this value after calling the method...",
             );
             err.span_note(sp, modifies_rcvr_note);
-            err.note(format!("...instead of the `()` output of method `{}`", path_segment.ident));
+            err.note(format!("...instead of the `()` output of method `{}`", path_segment.ident()));
         } else if let ExprKind::MethodCall(..) = rcvr.kind {
             err.span_note(
                 sp,