Rollup of 17 pull requests

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -283,3 +283,12 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcPreserveUbChecksParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcPreserveUbChecks;
 }
+
+pub(crate) struct RustcNoImplicitBoundsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcNoImplicitBoundsParser {
+    const PATH: &[Symbol] = &[sym::rustc_no_implicit_bounds];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcNoImplicitBounds;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -282,6 +282,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcMainParser>>,
         Single<WithoutArgs<RustcNeverReturnsNullPointerParser>>,
         Single<WithoutArgs<RustcNoImplicitAutorefsParser>>,
+        Single<WithoutArgs<RustcNoImplicitBoundsParser>>,
         Single<WithoutArgs<RustcNonConstTraitMethodParser>>,
         Single<WithoutArgs<RustcNounwindParser>>,
         Single<WithoutArgs<RustcOffloadKernelParser>>,

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1695,7 +1695,7 @@ fn suggest_ampmut<'tcx>(
                 && let Either::Left(rhs_stmt_new) = body.stmt_at(*assign)
                 && let StatementKind::Assign(box (_, rvalue_new)) = &rhs_stmt_new.kind
                 && let rhs_span_new = rhs_stmt_new.source_info.span
-                && let Ok(rhs_str_new) = tcx.sess.source_map().span_to_snippet(rhs_span)
+                && let Ok(rhs_str_new) = tcx.sess.source_map().span_to_snippet(rhs_span_new)
             {
                 (rvalue, rhs_span, rhs_str) = (rvalue_new, rhs_span_new, rhs_str_new);
             }

compiler/rustc_borrowck/src/lib.rs

@@ -121,6 +121,11 @@ fn mir_borrowck(
     let (input_body, _) = tcx.mir_promoted(def);
     debug!("run query mir_borrowck: {}", tcx.def_path_str(def));
 
+    // We should eagerly check stalled coroutine obligations from HIR typeck.
+    // Not doing so leads to silent normalization failures later, which will
+    // fail to register opaque types in the next solver.
+    tcx.check_coroutine_obligations(def)?;
+
     let input_body: &Body<'_> = &input_body.borrow();
     if let Some(guar) = input_body.tainted_by_errors {
         debug!("Skipping borrowck because of tainted body");

compiler/rustc_builtin_macros/src/asm.rs

@@ -288,6 +288,18 @@ fn expand_preparsed_asm(
         let msg = "asm template must be a string literal";
         let template_sp = template_expr.span;
         let template_is_mac_call = matches!(template_expr.kind, ast::ExprKind::MacCall(_));
+
+        // Gets the span inside `template_sp` corresponding to the given range
+        let span_in_template = |range: std::ops::Range<usize>| -> Span {
+            if template_is_mac_call {
+                // When the template is a macro call we can't reliably get inner spans
+                // so just use the entire template span (see ICEs #129503, #131292)
+                template_sp
+            } else {
+                template_sp.from_inner(InnerSpan::new(range.start, range.end))
+            }
+        };
+
         let ExprToSpannedString {
             symbol: template_str,
             style: template_style,
@@ -382,13 +394,8 @@ fn expand_preparsed_asm(
 
         if !parser.errors.is_empty() {
             let err = parser.errors.remove(0);
-            let err_sp = if template_is_mac_call {
-                // If the template is a macro call we can't reliably point to the error's
-                // span so just use the template's span as the error span (fixes #129503)
-                template_span
-            } else {
-                template_span.from_inner(InnerSpan::new(err.span.start, err.span.end))
-            };
+
+            let err_sp = span_in_template(err.span);
 
             let msg = format!("invalid asm template string: {}", err.description);
             let mut e = ecx.dcx().struct_span_err(err_sp, msg);
@@ -397,8 +404,7 @@ fn expand_preparsed_asm(
                 e.note(note);
             }
             if let Some((label, span)) = err.secondary_label {
-                let err_sp = template_span.from_inner(InnerSpan::new(span.start, span.end));
-                e.span_label(err_sp, label);
+                e.span_label(span_in_template(span), label);
             }
             let guar = e.emit();
             return ExpandResult::Ready(Err(guar));
@@ -477,8 +483,7 @@ fn expand_preparsed_asm(
                                     ecx.dcx()
                                         .create_err(errors::AsmNoMatchedArgumentName {
                                             name: name.to_owned(),
-                                            span: template_span
-                                                .from_inner(InnerSpan::new(span.start, span.end)),
+                                            span: span_in_template(span),
                                         })
                                         .emit();
                                     None
@@ -490,11 +495,7 @@ fn expand_preparsed_asm(
                     let mut chars = arg.format.ty.chars();
                     let mut modifier = chars.next();
                     if chars.next().is_some() {
-                        let span = arg
-                            .format
-                            .ty_span
-                            .map(|sp| template_sp.from_inner(InnerSpan::new(sp.start, sp.end)))
-                            .unwrap_or(template_sp);
+                        let span = arg.format.ty_span.map(span_in_template).unwrap_or(template_sp);
                         ecx.dcx().emit_err(errors::AsmModifierInvalid { span });
                         modifier = None;
                     }

compiler/rustc_builtin_macros/src/errors.rs

@@ -678,6 +678,18 @@ pub(crate) enum InvalidFormatStringSuggestion {
         #[primary_span]
         span: Span,
     },
+
+    #[suggestion(
+        "use rust debug printing macro",
+        code = "{replacement}",
+        style = "verbose",
+        applicability = "machine-applicable"
+    )]
+    UseRustDebugPrintingMacro {
+        #[primary_span]
+        macro_span: Span,
+        replacement: String,
+    },
 }
 
 #[derive(Diagnostic)]

compiler/rustc_builtin_macros/src/format.rs

@@ -160,6 +160,7 @@ fn make_format_args(
     ecx: &mut ExtCtxt<'_>,
     input: MacroInput,
     append_newline: bool,
+    macro_span: Span,
 ) -> ExpandResult<Result<FormatArgs, ErrorGuaranteed>, ()> {
     let msg = "format argument must be a string literal";
     let unexpanded_fmt_span = input.fmtstr.span;
@@ -333,6 +334,23 @@ fn make_format_args(
                 let span = fmt_span.from_inner(InnerSpan::new(span.start, span.end));
                 e.sugg_ = Some(errors::InvalidFormatStringSuggestion::AddMissingColon { span });
             }
+            parse::Suggestion::UseRustDebugPrintingMacro => {
+                // This targets `println!("{=}", x);` and `println!("{0=}", x);`
+                if let [arg] = args.all_args() {
+                    let expr_span = arg.expr.span;
+                    if let Ok(expr_snippet) = ecx.source_map().span_to_snippet(expr_span) {
+                        let replacement = format!("{}!({})", "dbg", expr_snippet);
+
+                        let call_span = macro_span.source_callsite();
+                        e.sugg_ = Some(
+                            errors::InvalidFormatStringSuggestion::UseRustDebugPrintingMacro {
+                                macro_span: call_span,
+                                replacement,
+                            },
+                        );
+                    }
+                }
+            }
         }
         let guar = ecx.dcx().emit_err(e);
         return ExpandResult::Ready(Err(guar));
@@ -1048,7 +1066,7 @@ fn expand_format_args_impl<'cx>(
     sp = ecx.with_def_site_ctxt(sp);
     ExpandResult::Ready(match parse_args(ecx, sp, tts) {
         Ok(input) => {
-            let ExpandResult::Ready(mac) = make_format_args(ecx, input, nl) else {
+            let ExpandResult::Ready(mac) = make_format_args(ecx, input, nl, sp) else {
                 return ExpandResult::Retry(());
             };
             match mac {

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1177,6 +1177,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_no_implicit_autorefs]`
     RustcNoImplicitAutorefs,
 
+    /// Represents `#[rustc_no_implicit_bounds]`
+    RustcNoImplicitBounds,
+
     /// Represents `#[rustc_non_const_trait_method]`.
     RustcNonConstTraitMethod,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -137,6 +137,7 @@ impl AttributeKind {
             RustcMustImplementOneOf { .. } => No,
             RustcNeverReturnsNullPointer => Yes,
             RustcNoImplicitAutorefs => Yes,
+            RustcNoImplicitBounds => No,
             RustcNonConstTraitMethod => No, // should be reported via other queries like `constness`
             RustcNounwind => No,
             RustcObjcClass { .. } => No,

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -4,15 +4,16 @@ use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::codes::*;
 use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
-use rustc_hir::PolyTraitRef;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
+use rustc_hir::{PolyTraitRef, find_attr};
 use rustc_middle::bug;
 use rustc_middle::ty::{
     self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
     TypeVisitor, Upcast,
 };
-use rustc_span::{ErrorGuaranteed, Ident, Span, kw, sym};
+use rustc_span::{ErrorGuaranteed, Ident, Span, kw};
 use rustc_trait_selection::traits;
 use smallvec::SmallVec;
 use tracing::{debug, instrument};
@@ -170,7 +171,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let tcx = self.tcx();
 
         // Skip adding any default bounds if `#![rustc_no_implicit_bounds]`
-        if tcx.has_attr(CRATE_DEF_ID, sym::rustc_no_implicit_bounds) {
+        if find_attr!(tcx.get_all_attrs(CRATE_DEF_ID), AttributeKind::RustcNoImplicitBounds) {
             return;
         }
 
@@ -284,7 +285,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         context: ImpliedBoundsContext<'tcx>,
     ) -> bool {
         let collected = collect_bounds(hir_bounds, context, trait_def_id);
-        !self.tcx().has_attr(CRATE_DEF_ID, sym::rustc_no_implicit_bounds) && !collected.any()
+        !find_attr!(self.tcx().get_all_attrs(CRATE_DEF_ID), AttributeKind::RustcNoImplicitBounds)
+            && !collected.any()
     }
 
     fn reject_duplicate_relaxed_bounds(&self, relaxed_bounds: SmallVec<[&PolyTraitRef<'_>; 1]>) {

compiler/rustc_interface/src/passes.rs

@@ -1116,18 +1116,14 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
             {
                 tcx.ensure_ok().mir_drops_elaborated_and_const_checked(def_id);
             }
-            if tcx.is_coroutine(def_id.to_def_id()) {
-                tcx.ensure_ok().mir_coroutine_witnesses(def_id);
-                let _ = tcx.ensure_ok().check_coroutine_obligations(
-                    tcx.typeck_root_def_id(def_id.to_def_id()).expect_local(),
+            if tcx.is_coroutine(def_id.to_def_id())
+                && (!tcx.is_async_drop_in_place_coroutine(def_id.to_def_id()))
+            {
+                // Eagerly check the unsubstituted layout for cycles.
+                tcx.ensure_ok().layout_of(
+                    ty::TypingEnv::post_analysis(tcx, def_id.to_def_id())
+                        .as_query_input(tcx.type_of(def_id).instantiate_identity()),
                 );
-                if !tcx.is_async_drop_in_place_coroutine(def_id.to_def_id()) {
-                    // Eagerly check the unsubstituted layout for cycles.
-                    tcx.ensure_ok().layout_of(
-                        ty::TypingEnv::post_analysis(tcx, def_id.to_def_id())
-                            .as_query_input(tcx.type_of(def_id).instantiate_identity()),
-                    );
-                }
             }
         });
     });

compiler/rustc_middle/src/ty/context/tls.rs

@@ -16,8 +16,7 @@ pub struct ImplicitCtxt<'a, 'tcx> {
     /// The current `TyCtxt`.
     pub tcx: TyCtxt<'tcx>,
 
-    /// The current query job, if any. This is updated by `JobOwner::start` in
-    /// `ty::query::plumbing` when executing a query.
+    /// The current query job, if any.
     pub query: Option<QueryJobId>,
 
     /// Used to prevent queries from calling too deeply.

compiler/rustc_parse/src/errors.rs

@@ -573,6 +573,24 @@ pub(crate) struct ExpectedExpressionFoundLet {
     pub comparison: Option<MaybeComparison>,
 }
 
+#[derive(Diagnostic)]
+#[diag("let-chain with missing `let`")]
+pub(crate) struct LetChainMissingLet {
+    #[primary_span]
+    pub span: Span,
+    #[label("expected `let` expression, found assignment")]
+    pub label_span: Span,
+    #[label("let expression later in the condition")]
+    pub rhs_span: Span,
+    #[suggestion(
+        "add `let` before the expression",
+        applicability = "maybe-incorrect",
+        code = "let ",
+        style = "verbose"
+    )]
+    pub sug_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("`||` operators are not supported in let chain conditions")]
 pub(crate) struct OrInLetChain {

compiler/rustc_parse/src/parser/expr.rs

@@ -4282,7 +4282,52 @@ impl MutVisitor for CondChecker<'_> {
                 mut_visit::walk_expr(self, e);
                 self.forbid_let_reason = forbid_let_reason;
             }
-            ExprKind::Assign(ref lhs, _, span) => {
+            ExprKind::Assign(ref lhs, ref rhs, span) => {
+                if let ExprKind::Call(_, _) = &lhs.kind {
+                    fn get_path_from_rhs(e: &Expr) -> Option<(u32, &Path)> {
+                        fn inner(e: &Expr, depth: u32) -> Option<(u32, &Path)> {
+                            match &e.kind {
+                                ExprKind::Binary(_, lhs, _) => inner(lhs, depth + 1),
+                                ExprKind::Path(_, path) => Some((depth, path)),
+                                _ => None,
+                            }
+                        }
+
+                        inner(e, 0)
+                    }
+
+                    if let Some((depth, path)) = get_path_from_rhs(rhs) {
+                        // For cases like if Some(_) = x && let Some(_) = y && let Some(_) = z
+                        // This return let Some(_) = y expression
+                        fn find_let_some(expr: &Expr) -> Option<&Expr> {
+                            match &expr.kind {
+                                ExprKind::Let(..) => Some(expr),
+
+                                ExprKind::Binary(op, lhs, rhs) if op.node == BinOpKind::And => {
+                                    find_let_some(lhs).or_else(|| find_let_some(rhs))
+                                }
+
+                                _ => None,
+                            }
+                        }
+
+                        let expr_span = lhs.span.to(path.span);
+
+                        if let Some(later_rhs) = find_let_some(rhs)
+                            && depth > 0
+                        {
+                            let guar = self.parser.dcx().emit_err(errors::LetChainMissingLet {
+                                span: lhs.span,
+                                label_span: expr_span,
+                                rhs_span: later_rhs.span,
+                                sug_span: lhs.span.shrink_to_lo(),
+                            });
+
+                            self.found_incorrect_let_chain = Some(guar);
+                        }
+                    }
+                }
+
                 let forbid_let_reason = self.forbid_let_reason;
                 self.forbid_let_reason = Some(errors::ForbiddenLetReason::OtherForbidden);
                 let missing_let = self.missing_let;

compiler/rustc_parse_format/src/lib.rs

@@ -187,6 +187,9 @@ pub enum Suggestion {
     /// Add missing colon:
     /// `format!("{foo?}")` -> `format!("{foo:?}")`
     AddMissingColon(Range<usize>),
+    /// Use Rust format string:
+    /// `format!("{x=}")` -> `dbg!(x)`
+    UseRustDebugPrintingMacro,
 }
 
 /// The parser structure for interpreting the input format string. This is
@@ -462,6 +465,7 @@ impl<'input> Parser<'input> {
                 ('?', _) => self.suggest_format_debug(),
                 ('<' | '^' | '>', _) => self.suggest_format_align(c),
                 (',', _) => self.suggest_unsupported_python_numeric_grouping(),
+                ('=', '}') => self.suggest_rust_debug_printing_macro(),
                 _ => self.suggest_positional_arg_instead_of_captured_arg(arg),
             }
         }
@@ -871,6 +875,27 @@ impl<'input> Parser<'input> {
         }
     }
 
+    fn suggest_rust_debug_printing_macro(&mut self) {
+        if let Some((range, _)) = self.consume_pos('=') {
+            self.errors.insert(
+                0,
+                ParseError {
+                    description:
+                        "python's f-string debug `=` is not supported in rust, use `dbg(x)` instead"
+                            .to_owned(),
+                    note: Some(format!("to print `{{`, you can escape it using `{{{{`",)),
+                    label: "expected `}`".to_owned(),
+                    span: range,
+                    secondary_label: self
+                        .last_open_brace
+                        .clone()
+                        .map(|sp| ("because of this opening brace".to_owned(), sp)),
+                    suggestion: Suggestion::UseRustDebugPrintingMacro,
+                },
+            );
+        }
+    }
+
     fn suggest_format_align(&mut self, alignment: char) {
         if let Some((range, _)) = self.consume_pos(alignment) {
             self.errors.insert(