Rollup of 13 pull requests

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

@@ -411,6 +411,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.impl_super_outlives(impl_def_id)
     }
 
+    fn supertrait_def_ids(self, trait_def_id: DefId) -> impl Iterator<Item = DefId> {
+        rustc_type_ir::elaborate::supertrait_def_ids(self, trait_def_id)
+    }
+
     fn impl_is_const(self, def_id: DefId) -> bool {
         debug_assert_matches!(self.def_kind(def_id), DefKind::Impl { of_trait: true });
         self.is_conditionally_const(def_id)

compiler/rustc_mir_transform/src/check_const_item_mutation.rs

@@ -2,7 +2,7 @@ use rustc_hir::HirId;
 use rustc_lint_defs::builtin::CONST_ITEM_MUTATION;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::*;
-use rustc_middle::ty::TyCtxt;
+use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 use rustc_span::Span;
 use rustc_span::def_id::DefId;
 
@@ -35,8 +35,9 @@ impl<'tcx> ConstMutationChecker<'_, 'tcx> {
     fn is_const_item_without_destructor(&self, local: Local) -> Option<DefId> {
         let def_id = self.is_const_item(local)?;
 
-        // We avoid linting mutation of a const item if the const's type has a
-        // Drop impl. The Drop logic observes the mutation which was performed.
+        // We avoid linting mutation of a const item if the const's type needs
+        // drop. Any drop logic (including that of fields) may observe the
+        // mutation which was performed.
         //
         //     pub struct Log { msg: &'static str }
         //     pub const LOG: Log = Log { msg: "" };
@@ -46,21 +47,30 @@ impl<'tcx> ConstMutationChecker<'_, 'tcx> {
         //
         //     LOG.msg = "wow";  // prints "wow"
         //
+        // Likewise, if a field of the const type has its own Drop impl, that
+        // drop logic may also observe the mutation:
+        //
+        //     struct Inner { val: u32 }
+        //     impl Drop for Inner { fn drop(&mut self) { println!("{}", self.val); } }
+        //     struct Outer { inner: Inner }
+        //     const O: Outer = Outer { inner: Inner { val: 0 } };
+        //
+        //     O.inner.val = 42;  // Inner::drop prints "42"
+        //
         // FIXME(https://github.com/rust-lang/rust/issues/77425):
         // Drop this exception once there is a stable attribute to suppress the
-        // const item mutation lint for a single specific const only. Something
-        // equivalent to:
-        //
-        //     #[const_mutation_allowed]
-        //     pub const LOG: Log = Log { msg: "" };
-        // FIXME: this should not be checking for `Drop` impls,
-        // but whether it or any field has a Drop impl (`needs_drop`)
-        // as fields' Drop impls may make this observable, too.
-        match self.tcx.type_of(def_id).skip_binder().ty_adt_def().map(|adt| adt.has_dtor(self.tcx))
-        {
-            Some(true) => None,
-            Some(false) | None => Some(def_id),
+        // const item mutation lint for a single specific const only.
+        let ty = self.tcx.type_of(def_id).instantiate_identity().skip_norm_wip();
+        // `needs_drop` is overly conservative for types that contain type
+        // parameters (e.g. `Self` in a trait associated const): it always
+        // returns `true` because the parameter *might* implement Drop, even
+        // when the concrete type at the call site does not. In that case we
+        // cannot suppress the lint, so fall through and warn.
+        if ty.has_param() {
+            return Some(def_id);
         }
+        let typing_env = ty::TypingEnv::non_body_analysis(self.tcx, def_id);
+        if ty.needs_drop(self.tcx, typing_env) { None } else { Some(def_id) }
     }
 
     /// If we should lint on this usage, return the [`HirId`], source [`Span`]

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -1096,7 +1096,8 @@ where
             .auto_traits()
             .into_iter()
             .chain(a_data.principal_def_id().into_iter().flat_map(|principal_def_id| {
-                elaborate::supertrait_def_ids(self.cx(), principal_def_id)
+                self.cx()
+                    .supertrait_def_ids(principal_def_id)
                     .filter(|def_id| self.cx().trait_is_auto(*def_id))
             }))
             .collect();

compiler/rustc_parse/src/parser/expr.rs

@@ -210,9 +210,7 @@ impl<'a> Parser<'a> {
                     let (rhs, span) = finish_parsing_bin_op(self)?;
                     self.mk_expr(span, ExprKind::Assign(lhs, rhs, op.span))
                 }
-                AssocOp::Cast => {
-                    self.parse_assoc_op_cast(lhs, lhs_span, op.span, ExprKind::Cast)?
-                }
+                AssocOp::Cast => self.parse_assoc_op_cast(lhs, lhs_span, op.span)?,
                 AssocOp::Range(limits) => self.parse_expr_range(min_prec, lhs, limits, op.span)?,
             };
 
@@ -555,17 +553,17 @@ impl<'a> Parser<'a> {
         lhs: Box<Expr>,
         lhs_span: Span,
         op_span: Span,
-        expr_kind: fn(Box<Expr>, Box<Ty>) -> ExprKind,
     ) -> PResult<'a, Box<Expr>> {
-        let mk_expr = |this: &mut Self, lhs: Box<Expr>, rhs: Box<Ty>| {
-            this.mk_expr(this.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span), expr_kind(lhs, rhs))
+        let mk_expr = |this: &mut Self, rhs: Box<Ty>| {
+            let span = this.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span);
+            this.mk_expr(span, ExprKind::Cast(lhs, rhs))
         };
 
         // Save the state of the parser before parsing type normally, in case there is a
         // LessThan comparison after this cast.
         let parser_snapshot_before_type = self.clone();
         let cast_expr = match self.parse_as_cast_ty() {
-            Ok(rhs) => mk_expr(self, lhs, rhs),
+            Ok(rhs) => mk_expr(self, rhs),
             Err(type_err) => {
                 if !self.may_recover() {
                     return Err(type_err);
@@ -576,46 +574,11 @@ impl<'a> Parser<'a> {
                 // `usize < y` as a type with generic arguments.
                 let parser_snapshot_after_type = mem::replace(self, parser_snapshot_before_type);
 
-                // Check for typo of `'a: loop { break 'a }` with a missing `'`.
-                match (&lhs.kind, &self.token.kind) {
-                    (
-                        // `foo: `
-                        ExprKind::Path(None, ast::Path { segments, .. }),
-                        token::Ident(kw::For | kw::Loop | kw::While, IdentIsRaw::No),
-                    ) if let [segment] = segments.as_slice() => {
-                        let snapshot = self.create_snapshot_for_diagnostic();
-                        let label = Label {
-                            ident: Ident::from_str_and_span(
-                                &format!("'{}", segment.ident),
-                                segment.ident.span,
-                            ),
-                        };
-                        match self.parse_expr_labeled(label, false) {
-                            Ok(expr) => {
-                                type_err.cancel();
-                                self.dcx().emit_err(crate::diagnostics::MalformedLoopLabel {
-                                    span: label.ident.span,
-                                    suggestion: label.ident.span.shrink_to_lo(),
-                                });
-                                return Ok(expr);
-                            }
-                            Err(err) => {
-                                err.cancel();
-                                self.restore_snapshot(snapshot);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-
                 match self.parse_path(PathStyle::Expr) {
                     Ok(path) => {
                         let span_after_type = parser_snapshot_after_type.token.span;
-                        let expr = mk_expr(
-                            self,
-                            lhs,
-                            self.mk_ty(path.span, TyKind::Path(None, path.clone())),
-                        );
+                        let expr =
+                            mk_expr(self, self.mk_ty(path.span, TyKind::Path(None, path.clone())));
 
                         let args_span = self.look_ahead(1, |t| t.span).to(span_after_type);
                         match self.token.kind {
@@ -674,48 +637,38 @@ impl<'a> Parser<'a> {
         // written `((&x) as T)[0]`.
 
         let span = cast_expr.span;
-
         let with_postfix = self.parse_expr_dot_or_call_with(AttrVec::new(), cast_expr, span)?;
 
         // Check if an illegal postfix operator has been added after the cast.
         // If the resulting expression is not a cast, it is an illegal postfix operator.
         if !matches!(with_postfix.kind, ExprKind::Cast(_, _)) {
-            let msg = format!(
-                "cast cannot be followed by {}",
-                match with_postfix.kind {
-                    ExprKind::Index(..) => "indexing",
-                    ExprKind::Try(_) => "`?`",
-                    ExprKind::Field(_, _) => "a field access",
-                    ExprKind::MethodCall(_) => "a method call",
-                    ExprKind::Call(_, _) => "a function call",
-                    ExprKind::Await(_, _) => "`.await`",
-                    ExprKind::Use(_, _) => "`.use`",
-                    ExprKind::Yield(YieldKind::Postfix(_)) => "`.yield`",
-                    ExprKind::Match(_, _, MatchKind::Postfix) => "a postfix match",
-                    ExprKind::Err(_) => return Ok(with_postfix),
-                    _ => unreachable!(
-                        "did not expect {:?} as an illegal postfix operator following cast",
-                        with_postfix.kind
-                    ),
-                }
-            );
-            let mut err = self.dcx().struct_span_err(span, msg);
-
-            let suggest_parens = |err: &mut Diag<'_>| {
-                let suggestions = vec![
-                    (span.shrink_to_lo(), "(".to_string()),
-                    (span.shrink_to_hi(), ")".to_string()),
-                ];
-                err.multipart_suggestion(
+            let kind = match with_postfix.kind {
+                ExprKind::Index(..) => "indexing",
+                ExprKind::Try(_) => "`?`",
+                ExprKind::Field(_, _) => "a field access",
+                ExprKind::MethodCall(_) => "a method call",
+                ExprKind::Call(_, _) => "a function call",
+                ExprKind::Await(_, _) => "`.await`",
+                ExprKind::Use(_, _) => "`.use`",
+                ExprKind::Yield(YieldKind::Postfix(_)) => "`.yield`",
+                ExprKind::Match(_, _, MatchKind::Postfix) => "a postfix match",
+                ExprKind::Err(_) => return Ok(with_postfix),
+                _ => unreachable!(
+                    "did not expect {:?} as an illegal postfix operator following cast",
+                    with_postfix.kind
+                ),
+            };
+            self.dcx()
+                .struct_span_err(span, format!("cast cannot be followed by {kind}"))
+                .with_multipart_suggestion(
                     "try surrounding the expression in parentheses",
-                    suggestions,
+                    vec![
+                        (span.shrink_to_lo(), "(".to_string()),
+                        (span.shrink_to_hi(), ")".to_string()),
+                    ],
                     Applicability::MachineApplicable,
-                );
-            };
-
-            suggest_parens(&mut err);
-
-            err.emit();
+                )
+                .emit();
         };
         Ok(with_postfix)
     }
@@ -1401,6 +1354,9 @@ impl<'a> Parser<'a> {
                 if let Some(expr) = this.maybe_recover_bad_struct_literal_path(false)? {
                     return Ok(expr);
                 }
+                if let Some(arr) = this.recover_from_c_array(lo) {
+                    return Ok(arr);
+                }
                 this.parse_expr_block(None, lo, BlockCheckMode::Default)
             } else if this.check(exp!(Or)) || this.check(exp!(OrOr)) {
                 this.parse_expr_closure().map_err(|mut err| {
@@ -2227,39 +2183,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn is_array_like_block(&mut self) -> bool {
-        self.token.kind == TokenKind::OpenBrace
-            && self
-                .look_ahead(1, |t| matches!(t.kind, TokenKind::Ident(..) | TokenKind::Literal(_)))
-            && self.look_ahead(2, |t| t == &token::Comma)
-            && self.look_ahead(3, |t| t.can_begin_expr())
-    }
-
-    /// Emits a suggestion if it looks like the user meant an array but
-    /// accidentally used braces, causing the code to be interpreted as a block
-    /// expression.
-    fn maybe_suggest_brackets_instead_of_braces(&mut self, lo: Span) -> Option<Box<Expr>> {
-        let mut snapshot = self.create_snapshot_for_diagnostic();
-        match snapshot.parse_expr_array_or_repeat(exp!(CloseBrace)) {
-            Ok(arr) => {
-                let guar = self.dcx().emit_err(crate::diagnostics::ArrayBracketsInsteadOfBraces {
-                    span: arr.span,
-                    sub: crate::diagnostics::ArrayBracketsInsteadOfBracesSugg {
-                        left: lo,
-                        right: snapshot.prev_token.span,
-                    },
-                });
-
-                self.restore_snapshot(snapshot);
-                Some(self.mk_expr_err(arr.span, guar))
-            }
-            Err(e) => {
-                e.cancel();
-                None
-            }
-        }
-    }
-
     fn suggest_missing_semicolon_before_array(
         &self,
         prev_span: Span,
@@ -2309,12 +2232,6 @@ impl<'a> Parser<'a> {
         lo: Span,
         blk_mode: BlockCheckMode,
     ) -> PResult<'a, Box<Expr>> {
-        if self.may_recover() && self.is_array_like_block() {
-            if let Some(arr) = self.maybe_suggest_brackets_instead_of_braces(lo) {
-                return Ok(arr);
-            }
-        }
-
         if self.token.is_metavar_block() {
             self.dcx().emit_err(crate::diagnostics::InvalidBlockMacroSegment {
                 span: self.token.span,

compiler/rustc_parse/src/parser/expr/diagnostics.rs

@@ -3,8 +3,8 @@ use rustc_ast::{BinOpKind, Expr, ExprKind, token};
 use rustc_errors::{Applicability, Diag, PResult};
 use rustc_span::{Span, Spanned, respan, sym};
 
-use crate::diagnostics;
 use crate::parser::Parser;
+use crate::{diagnostics, exp};
 
 impl<'a> Parser<'a> {
     /// Recover from alphabetic logic operators `and` and `or` as found in e.g., Python and PHP.
@@ -216,6 +216,38 @@ impl<'a> Parser<'a> {
         }
         err
     }
+
+    /// Recover from array expressions as found in C like `{0, 1, 2, 3}`.
+    pub(super) fn recover_from_c_array(&mut self, lo: Span) -> Option<Box<Expr>> {
+        if !self.may_recover()
+            || self.token.kind != token::OpenBrace
+            || self.look_ahead(1, |t| !matches!(t.kind, token::Literal(_)))
+            || self.look_ahead(2, |t| t != &token::Comma)
+            || self.look_ahead(3, |t| !t.can_begin_expr())
+        {
+            return None;
+        }
+
+        let mut snapshot = self.create_snapshot_for_diagnostic();
+        match snapshot.parse_expr_array_or_repeat(exp!(CloseBrace)) {
+            Ok(arr) => {
+                let guar = self.dcx().emit_err(diagnostics::ArrayBracketsInsteadOfBraces {
+                    span: arr.span,
+                    sub: diagnostics::ArrayBracketsInsteadOfBracesSugg {
+                        left: lo,
+                        right: snapshot.prev_token.span,
+                    },
+                });
+
+                self.restore_snapshot(snapshot);
+                Some(self.mk_expr_err(arr.span, guar))
+            }
+            Err(e) => {
+                e.cancel();
+                None
+            }
+        }
+    }
 }
 
 #[derive(Copy, Clone)]