Rollup of 15 pull requests

compiler/rustc_hir_typeck/src/expr.rs

@@ -617,6 +617,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     call_expr_and_args.map_or(expr.span, |(e, _)| e.span),
                     expr.span,
                     expr.hir_id,
+                    call_expr_and_args.is_some(),
                 )
                 .0
             }

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1006,6 +1006,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         span: Span,
         path_span: Span,
         hir_id: HirId,
+        has_args: bool,
     ) -> (Ty<'tcx>, Res) {
         let tcx = self.tcx;
 
@@ -1253,17 +1254,50 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         "the `Self` constructor can only be used with tuple or unit structs",
                     );
                     if let Some(adt_def) = ty.normalized.ty_adt_def() {
-                        match adt_def.adt_kind() {
-                            AdtKind::Enum => {
-                                err.help("did you mean to use one of the enum's variants?");
-                            }
-                            AdtKind::Struct | AdtKind::Union => {
-                                err.span_suggestion(
-                                    span,
-                                    "use curly brackets",
-                                    "Self { /* fields */ }",
-                                    Applicability::HasPlaceholders,
-                                );
+                        let def_id = self.body_def_id.to_def_id();
+                        if !has_args
+                            && let Some(assoc) = tcx.opt_associated_item(def_id)
+                            && assoc.is_method()
+                        {
+                            let self_ty =
+                                tcx.fn_sig(def_id).instantiate_identity().skip_binder().inputs()[0];
+                            let applicability = if let ty::Adt(..) = self_ty.kind() {
+                                // We're within a method that takes ownership of `Self`, likely a
+                                // builder, so this is most likely a typo.
+                                Applicability::MachineApplicable
+                            } else {
+                                // We still might have meant `self` instead of `Self`.
+                                Applicability::MaybeIncorrect
+                            };
+                            err.span_suggestion_verbose(
+                                span,
+                                format!(
+                                    "you might have meant to refer to the `self` binding of type \
+                                     `{self_ty}`",
+                                ),
+                                "self".to_string(),
+                                applicability,
+                            );
+                        } else {
+                            match adt_def.adt_kind() {
+                                AdtKind::Enum => {
+                                    err.span_help(
+                                        tcx.def_span(adt_def.did()),
+                                        if adt_def.variants().is_empty() {
+                                            "the enum is unconstructable because it has no variants"
+                                        } else {
+                                            "you might have meant to use one of the enum's variants"
+                                        },
+                                    );
+                                }
+                                AdtKind::Struct | AdtKind::Union => {
+                                    err.span_suggestion_verbose(
+                                        span,
+                                        "use curly brackets",
+                                        "Self { /* fields */ }",
+                                        Applicability::HasPlaceholders,
+                                    );
+                                }
                             }
                         }
                     }

compiler/rustc_hir_typeck/src/pat.rs

@@ -911,7 +911,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             rustc_hir::PatExprKind::Path(qpath) => {
                 let (res, opt_ty, segments) =
                     self.resolve_ty_and_res_fully_qualified_call(qpath, lt.hir_id, lt.span);
-                self.instantiate_value_path(segments, opt_ty, res, lt.span, lt.span, lt.hir_id).0
+                self.instantiate_value_path(
+                    segments, opt_ty, res, lt.span, lt.span, lt.hir_id, false,
+                )
+                .0
             }
         };
         self.write_ty(lt.hir_id, ty);
@@ -1624,7 +1627,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // Find the type of the path pattern, for later checking.
         let (pat_ty, pat_res) =
-            self.instantiate_value_path(segments, opt_ty, res, span, span, path_id);
+            self.instantiate_value_path(segments, opt_ty, res, span, span, path_id, false);
         Ok(ResolvedPat { ty: pat_ty, kind: ResolvedPatKind::Path { res, pat_res, segments } })
     }
 
@@ -1784,8 +1787,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
 
         // Type-check the path.
-        let (pat_ty, res) =
-            self.instantiate_value_path(segments, opt_ty, res, pat.span, pat.span, pat.hir_id);
+        let (pat_ty, res) = self
+            .instantiate_value_path(segments, opt_ty, res, pat.span, pat.span, pat.hir_id, false);
         if !pat_ty.is_fn() {
             return report_unexpected_res(res);
         }

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();