Rollup of 14 pull requests

compiler/rustc_ast/src/util/parser.rs

@@ -233,8 +233,7 @@ pub const PREC_JUMP: i8 = -30;
 pub const PREC_RANGE: i8 = -10;
 // The range 2..=14 is reserved for AssocOp binary operator precedences.
 pub const PREC_PREFIX: i8 = 50;
-pub const PREC_POSTFIX: i8 = 60;
-pub const PREC_PAREN: i8 = 99;
+pub const PREC_UNAMBIGUOUS: i8 = 60;
 pub const PREC_FORCE_PAREN: i8 = 100;
 
 #[derive(Debug, Clone, Copy)]
@@ -325,37 +324,35 @@ impl ExprPrecedence {
             | ExprPrecedence::Let
             | ExprPrecedence::Unary => PREC_PREFIX,
 
-            // Unary, postfix
-            ExprPrecedence::Await
+            // Never need parens
+            ExprPrecedence::Array
+            | ExprPrecedence::Await
+            | ExprPrecedence::Block
             | ExprPrecedence::Call
-            | ExprPrecedence::MethodCall
+            | ExprPrecedence::ConstBlock
             | ExprPrecedence::Field
+            | ExprPrecedence::ForLoop
+            | ExprPrecedence::FormatArgs
+            | ExprPrecedence::Gen
+            | ExprPrecedence::If
             | ExprPrecedence::Index
-            | ExprPrecedence::Try
             | ExprPrecedence::InlineAsm
+            | ExprPrecedence::Lit
+            | ExprPrecedence::Loop
             | ExprPrecedence::Mac
-            | ExprPrecedence::FormatArgs
+            | ExprPrecedence::Match
+            | ExprPrecedence::MethodCall
             | ExprPrecedence::OffsetOf
-            | ExprPrecedence::PostfixMatch => PREC_POSTFIX,
-
-            // Never need parens
-            ExprPrecedence::Array
+            | ExprPrecedence::Paren
+            | ExprPrecedence::Path
+            | ExprPrecedence::PostfixMatch
             | ExprPrecedence::Repeat
+            | ExprPrecedence::Struct
+            | ExprPrecedence::Try
+            | ExprPrecedence::TryBlock
             | ExprPrecedence::Tup
-            | ExprPrecedence::Lit
-            | ExprPrecedence::Path
-            | ExprPrecedence::Paren
-            | ExprPrecedence::If
             | ExprPrecedence::While
-            | ExprPrecedence::ForLoop
-            | ExprPrecedence::Loop
-            | ExprPrecedence::Match
-            | ExprPrecedence::ConstBlock
-            | ExprPrecedence::Block
-            | ExprPrecedence::TryBlock
-            | ExprPrecedence::Gen
-            | ExprPrecedence::Struct
-            | ExprPrecedence::Err => PREC_PAREN,
+            | ExprPrecedence::Err => PREC_UNAMBIGUOUS,
         }
     }
 }

compiler/rustc_ast_lowering/messages.ftl

@@ -130,6 +130,9 @@ ast_lowering_never_pattern_with_guard =
 
 ast_lowering_no_precise_captures_on_apit = `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
 
+ast_lowering_no_precise_captures_on_rpitit = `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+    .note = currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
 ast_lowering_previously_used_here = previously used here
 
 ast_lowering_register1 = register `{$reg1_name}`

compiler/rustc_ast_lowering/src/delegation.rs

@@ -66,14 +66,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let Ok(sig_id) = sig_id else {
             return false;
         };
-        if let Some(local_sig_id) = sig_id.as_local() {
+        self.has_self(sig_id, span)
+    }
+
+    fn has_self(&self, def_id: DefId, span: Span) -> bool {
+        if let Some(local_sig_id) = def_id.as_local() {
             // The value may be missing due to recursive delegation.
             // Error will be emmited later during HIR ty lowering.
             self.resolver.delegation_fn_sigs.get(&local_sig_id).map_or(false, |sig| sig.has_self)
         } else {
-            match self.tcx.def_kind(sig_id) {
+            match self.tcx.def_kind(def_id) {
                 DefKind::Fn => false,
-                DefKind::AssocFn => self.tcx.associated_item(sig_id).fn_has_self_parameter,
+                DefKind::AssocFn => self.tcx.associated_item(def_id).fn_has_self_parameter,
                 _ => span_bug!(span, "unexpected DefKind for delegation item"),
             }
         }
@@ -107,12 +111,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
         span: Span,
     ) -> Result<DefId, ErrorGuaranteed> {
         let sig_id = if self.is_in_trait_impl { item_id } else { path_id };
-        let sig_id =
-            self.resolver.get_partial_res(sig_id).and_then(|r| r.expect_full_res().opt_def_id());
-        sig_id.ok_or_else(|| {
-            self.tcx
-                .dcx()
-                .span_delayed_bug(span, "LoweringContext: couldn't resolve delegation item")
+        self.get_resolution_id(sig_id, span)
+    }
+
+    fn get_resolution_id(&self, node_id: NodeId, span: Span) -> Result<DefId, ErrorGuaranteed> {
+        let def_id =
+            self.resolver.get_partial_res(node_id).and_then(|r| r.expect_full_res().opt_def_id());
+        def_id.ok_or_else(|| {
+            self.tcx.dcx().span_delayed_bug(
+                span,
+                format!("LoweringContext: couldn't resolve node {:?} in delegation item", node_id),
+            )
         })
     }
 
@@ -122,7 +131,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             predicates: &[],
             has_where_clause_predicates: false,
             where_clause_span: span,
-            span: span,
+            span,
         })
     }
 
@@ -222,12 +231,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }));
 
         let path = self.arena.alloc(hir::Path { span, res: Res::Local(param_id), segments });
-
-        hir::Expr {
-            hir_id: self.next_id(),
-            kind: hir::ExprKind::Path(hir::QPath::Resolved(None, path)),
-            span,
-        }
+        self.mk_expr(hir::ExprKind::Path(hir::QPath::Resolved(None, path)), span)
     }
 
     fn lower_delegation_body(
@@ -236,19 +240,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         param_count: usize,
         span: Span,
     ) -> BodyId {
-        let path = self.lower_qpath(
-            delegation.id,
-            &delegation.qself,
-            &delegation.path,
-            ParamMode::Optional,
-            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
-            None,
-        );
         let block = delegation.body.as_deref();
 
         self.lower_body(|this| {
-            let mut parameters: Vec<hir::Param<'_>> = Vec::new();
-            let mut args: Vec<hir::Expr<'hir>> = Vec::new();
+            let mut parameters: Vec<hir::Param<'_>> = Vec::with_capacity(param_count);
+            let mut args: Vec<hir::Expr<'_>> = Vec::with_capacity(param_count);
 
             for idx in 0..param_count {
                 let (param, pat_node_id) = this.generate_param(span);
@@ -264,55 +260,49 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     };
                     self_resolver.visit_block(block);
                     let block = this.lower_block(block, false);
-                    hir::Expr {
-                        hir_id: this.next_id(),
-                        kind: hir::ExprKind::Block(block, None),
-                        span: block.span,
-                    }
+                    this.mk_expr(hir::ExprKind::Block(block, None), block.span)
                 } else {
                     let pat_hir_id = this.lower_node_id(pat_node_id);
                     this.generate_arg(pat_hir_id, span)
                 };
                 args.push(arg);
             }
 
-            let args = self.arena.alloc_from_iter(args);
-            let final_expr = this.generate_call(path, args);
+            let final_expr = this.finalize_body_lowering(delegation, args, span);
             (this.arena.alloc_from_iter(parameters), final_expr)
         })
     }
 
-    fn generate_call(
+    // Generates fully qualified call for the resulting body.
+    fn finalize_body_lowering(
         &mut self,
-        path: hir::QPath<'hir>,
-        args: &'hir [hir::Expr<'hir>],
+        delegation: &Delegation,
+        args: Vec<hir::Expr<'hir>>,
+        span: Span,
     ) -> hir::Expr<'hir> {
-        let callee = self.arena.alloc(hir::Expr {
-            hir_id: self.next_id(),
-            kind: hir::ExprKind::Path(path),
-            span: path.span(),
-        });
+        let path = self.lower_qpath(
+            delegation.id,
+            &delegation.qself,
+            &delegation.path,
+            ParamMode::Optional,
+            ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+            None,
+        );
 
-        let expr = self.arena.alloc(hir::Expr {
-            hir_id: self.next_id(),
-            kind: hir::ExprKind::Call(callee, args),
-            span: path.span(),
-        });
+        let args = self.arena.alloc_from_iter(args);
+        let path_expr = self.arena.alloc(self.mk_expr(hir::ExprKind::Path(path), span));
+        let call = self.arena.alloc(self.mk_expr(hir::ExprKind::Call(path_expr, args), span));
 
         let block = self.arena.alloc(hir::Block {
             stmts: &[],
-            expr: Some(expr),
+            expr: Some(call),
             hir_id: self.next_id(),
             rules: hir::BlockCheckMode::DefaultBlock,
-            span: path.span(),
+            span,
             targeted_by_break: false,
         });
 
-        hir::Expr {
-            hir_id: self.next_id(),
-            kind: hir::ExprKind::Block(block, None),
-            span: path.span(),
-        }
+        self.mk_expr(hir::ExprKind::Block(block, None), span)
     }
 
     fn generate_delegation_error(
@@ -333,11 +323,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let header = self.generate_header_error();
         let sig = hir::FnSig { decl, header, span };
 
-        let body_id = self.lower_body(|this| {
-            let expr =
-                hir::Expr { hir_id: this.next_id(), kind: hir::ExprKind::Err(err), span: span };
-            (&[], expr)
-        });
+        let body_id = self.lower_body(|this| (&[], this.mk_expr(hir::ExprKind::Err(err), span)));
         DelegationResults { generics, body_id, sig }
     }
 
@@ -349,6 +335,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             abi: abi::Abi::Rust,
         }
     }
+
+    #[inline]
+    fn mk_expr(&mut self, kind: hir::ExprKind<'hir>, span: Span) -> hir::Expr<'hir> {
+        hir::Expr { hir_id: self.next_id(), kind, span }
+    }
 }
 
 struct SelfResolver<'a> {

compiler/rustc_ast_lowering/src/errors.rs

@@ -424,6 +424,14 @@ pub(crate) struct NoPreciseCapturesOnApit {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_lowering_no_precise_captures_on_rpitit)]
+#[note]
+pub(crate) struct NoPreciseCapturesOnRpitit {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_lowering_yield_in_closure)]
 pub(crate) struct YieldInClosure {

compiler/rustc_ast_lowering/src/lib.rs

@@ -1594,6 +1594,26 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
         debug!(?captured_lifetimes_to_duplicate);
 
+        match fn_kind {
+            // Deny `use<>` on RPITIT in trait/trait-impl for now.
+            Some(FnDeclKind::Trait | FnDeclKind::Impl) => {
+                if let Some(span) = bounds.iter().find_map(|bound| match *bound {
+                    ast::GenericBound::Use(_, span) => Some(span),
+                    _ => None,
+                }) {
+                    self.tcx.dcx().emit_err(errors::NoPreciseCapturesOnRpitit { span });
+                }
+            }
+            None
+            | Some(
+                FnDeclKind::Fn
+                | FnDeclKind::Inherent
+                | FnDeclKind::ExternFn
+                | FnDeclKind::Closure
+                | FnDeclKind::Pointer,
+            ) => {}
+        }
+
         self.lower_opaque_inner(
             opaque_ty_node_id,
             origin,

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

@@ -217,7 +217,7 @@ impl<'a> State<'a> {
     fn print_expr_call(&mut self, func: &ast::Expr, args: &[P<ast::Expr>], fixup: FixupContext) {
         let prec = match func.kind {
             ast::ExprKind::Field(..) => parser::PREC_FORCE_PAREN,
-            _ => parser::PREC_POSTFIX,
+            _ => parser::PREC_UNAMBIGUOUS,
         };
 
         // Independent of parenthesization related to precedence, we must
@@ -257,7 +257,7 @@ impl<'a> State<'a> {
         // boundaries, `$receiver.method()` can be parsed back as a statement
         // containing an expression if and only if `$receiver` can be parsed as
         // a statement containing an expression.
-        self.print_expr_maybe_paren(receiver, parser::PREC_POSTFIX, fixup);
+        self.print_expr_maybe_paren(receiver, parser::PREC_UNAMBIGUOUS, fixup);
 
         self.word(".");
         self.print_ident(segment.ident);
@@ -489,7 +489,7 @@ impl<'a> State<'a> {
                         self.space();
                     }
                     MatchKind::Postfix => {
-                        self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX, fixup);
+                        self.print_expr_maybe_paren(expr, parser::PREC_UNAMBIGUOUS, fixup);
                         self.word_nbsp(".match");
                     }
                 }
@@ -549,7 +549,7 @@ impl<'a> State<'a> {
                 self.print_block_with_attrs(blk, attrs);
             }
             ast::ExprKind::Await(expr, _) => {
-                self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX, fixup);
+                self.print_expr_maybe_paren(expr, parser::PREC_UNAMBIGUOUS, fixup);
                 self.word(".await");
             }
             ast::ExprKind::Assign(lhs, rhs, _) => {
@@ -568,14 +568,14 @@ impl<'a> State<'a> {
                 self.print_expr_maybe_paren(rhs, prec, fixup.subsequent_subexpression());
             }
             ast::ExprKind::Field(expr, ident) => {
-                self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX, fixup);
+                self.print_expr_maybe_paren(expr, parser::PREC_UNAMBIGUOUS, fixup);
                 self.word(".");
                 self.print_ident(*ident);
             }
             ast::ExprKind::Index(expr, index, _) => {
                 self.print_expr_maybe_paren(
                     expr,
-                    parser::PREC_POSTFIX,
+                    parser::PREC_UNAMBIGUOUS,
                     fixup.leftmost_subexpression(),
                 );
                 self.word("[");
@@ -713,7 +713,7 @@ impl<'a> State<'a> {
                 }
             }
             ast::ExprKind::Try(e) => {
-                self.print_expr_maybe_paren(e, parser::PREC_POSTFIX, fixup);
+                self.print_expr_maybe_paren(e, parser::PREC_UNAMBIGUOUS, fixup);
                 self.word("?")
             }
             ast::ExprKind::TryBlock(blk) => {

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1151,7 +1151,9 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, '_, 'tcx> {
         // Get the arguments for the found method, only specifying that `Self` is the receiver type.
         let Some(possible_rcvr_ty) = typeck_results.node_type_opt(rcvr.hir_id) else { return };
         let args = GenericArgs::for_item(tcx, method_def_id, |param, _| {
-            if param.index == 0 {
+            if let ty::GenericParamDefKind::Lifetime = param.kind {
+                tcx.lifetimes.re_erased.into()
+            } else if param.index == 0 && param.name == kw::SelfUpper {
                 possible_rcvr_ty.into()
             } else if param.index == closure_param.index {
                 closure_ty.into()
@@ -1168,7 +1170,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, '_, 'tcx> {
             Obligation::misc(tcx, span, self.mir_def_id(), self.param_env, pred)
         }));
 
-        if ocx.select_all_or_error().is_empty() {
+        if ocx.select_all_or_error().is_empty() && count > 0 {
             diag.span_suggestion_verbose(
                 tcx.hir().body(*body).value.peel_blocks().span.shrink_to_lo(),
                 "dereference the return value",