Auto merge of #73367 - RalfJung:rollup-4ewvk9b, r=RalfJung

Rollup of 10 pull requests

Successful merges:

 - #71824 (Check for live drops in constants after drop elaboration)
 - #72389 (Explain move errors that occur due to method calls involving `self`)
 - #72556 (Fix trait alias inherent impl resolution)
 - #72584 (Stabilize vec::Drain::as_slice)
 - #72598 (Display information about captured variable in `FnMut` error)
 - #73336 (Group `Pattern::strip_*` method together)
 - #73341 (_match.rs: fix module doc comment)
 - #73342 (Fix iterator copied() documentation example code)
 - #73351 (Update E0446.md)
 - #73353 (structural_match: non-structural-match ty closures)

Failed merges:

r? @ghost

src/liballoc/vec.rs

@@ -2779,19 +2779,25 @@ impl<'a, T> Drain<'a, T> {
  /// # Examples
  ///
  /// ```
- /// # #![feature(vec_drain_as_slice)]
  /// let mut vec = vec!['a', 'b', 'c'];
  /// let mut drain = vec.drain(..);
  /// assert_eq!(drain.as_slice(), &['a', 'b', 'c']);
  /// let _ = drain.next().unwrap();
  /// assert_eq!(drain.as_slice(), &['b', 'c']);
  /// ```
- #[unstable(feature = "vec_drain_as_slice", reason = "recently added", issue = "58957")]
+ #[stable(feature = "vec_drain_as_slice", since = "1.46.0")]
  pub fn as_slice(&self) -> &[T] {
  self.iter.as_slice()
  }
 }
 
+#[stable(feature = "vec_drain_as_slice", since = "1.46.0")]
+impl<'a, T> AsRef<[T]> for Drain<'a, T> {
+ fn as_ref(&self) -> &[T] {
+ self.as_slice()
+ }
+}
+
 #[stable(feature = "drain", since = "1.6.0")]
 unsafe impl<T: Sync> Sync for Drain<'_, T> {}
 #[stable(feature = "drain", since = "1.6.0")]

src/libcore/future/mod.rs

@@ -56,6 +56,7 @@ pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
 where
  T: Generator<ResumeTy, Yield = ()>,
 {
+ #[rustc_diagnostic_item = "gen_future"]
  struct GenFuture<T: Generator<ResumeTy, Yield = ()>>(T);
 
  // We rely on the fact that async/await futures are immovable in order to create

src/libcore/iter/traits/iterator.rs

@@ -2717,12 +2717,12 @@ pub trait Iterator {
  /// ```
  /// let a = [1, 2, 3];
  ///
- /// let v_cloned: Vec<_> = a.iter().copied().collect();
+ /// let v_copied: Vec<_> = a.iter().copied().collect();
  ///
  /// // copied is the same as .map(|&x| x)
  /// let v_map: Vec<_> = a.iter().map(|&x| x).collect();
  ///
- /// assert_eq!(v_cloned, vec![1, 2, 3]);
+ /// assert_eq!(v_copied, vec![1, 2, 3]);
  /// assert_eq!(v_map, vec![1, 2, 3]);
  /// ```
  #[stable(feature = "iter_copied", since = "1.36.0")]

src/libcore/str/pattern.rs

@@ -69,7 +69,7 @@ use crate::slice::memchr;
 /// |--------------------------|-------------------------------------------|
 /// | `&str` | is substring |
 /// | `char` | is contained in string |
-/// | `&[char]  | any char in slice is contained in string |
+/// | `&[char]` | any char in slice is contained in string |
 /// | `F: FnMut(char) -> bool` | `F` returns `true` for a char in string |
 /// | `&&str` | is substring |
 /// | `&String` | is substring |
@@ -117,6 +117,15 @@ pub trait Pattern<'a>: Sized {
  matches!(self.into_searcher(haystack).next(), SearchStep::Match(0, _))
  }
 
+ /// Checks whether the pattern matches at the back of the haystack
+ #[inline]
+ fn is_suffix_of(self, haystack: &'a str) -> bool
+ where
+ Self::Searcher: ReverseSearcher<'a>,
+ {
+ matches!(self.into_searcher(haystack).next_back(), SearchStep::Match(_, j) if haystack.len() == j)
+ }
+
  /// Removes the pattern from the front of haystack, if it matches.
  #[inline]
  fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> {
@@ -133,15 +142,6 @@ pub trait Pattern<'a>: Sized {
  }
  }
 
- /// Checks whether the pattern matches at the back of the haystack
- #[inline]
- fn is_suffix_of(self, haystack: &'a str) -> bool
- where
- Self::Searcher: ReverseSearcher<'a>,
- {
- matches!(self.into_searcher(haystack).next_back(), SearchStep::Match(_, j) if haystack.len() == j)
- }
-
  /// Removes the pattern from the back of haystack, if it matches.
  #[inline]
  fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>

src/librustc_ast_lowering/expr.rs

@@ -9,7 +9,7 @@ use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::struct_span_err;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
-use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned};
+use rustc_span::source_map::{respan, DesugaringKind, ForLoopLoc, Span, Spanned};
 use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_target::asm;
 use std::collections::hash_map::Entry;
@@ -25,6 +25,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }
 
  pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
+ let mut span = e.span;
  ensure_sufficient_stack(|| {
  let kind = match e.kind {
  ExprKind::Box(ref inner) => hir::ExprKind::Box(self.lower_expr(inner)),
@@ -53,6 +54,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  hir::ExprKind::MethodCall(hir_seg, seg.ident.span, args, span)
  }
  ExprKind::Binary(binop, ref lhs, ref rhs) => {
+ span = self.mark_span_with_reason(DesugaringKind::Operator, e.span, None);
  let binop = self.lower_binop(binop);
  let lhs = self.lower_expr(lhs);
  let rhs = self.lower_expr(rhs);
@@ -222,7 +224,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  hir::Expr {
  hir_id: self.lower_node_id(e.id),
  kind,
- span: e.span,
+ span,
  attrs: e.attrs.iter().map(|a| self.lower_attr(a)).collect::<Vec<_>>().into(),
  }
  })
@@ -237,6 +239,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }
 
  fn lower_binop(&mut self, b: BinOp) -> hir::BinOp {
+ let span = self.mark_span_with_reason(DesugaringKind::Operator, b.span, None);
  Spanned {
  node: match b.node {
  BinOpKind::Add => hir::BinOpKind::Add,
@@ -258,7 +261,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  BinOpKind::Ge => hir::BinOpKind::Ge,
  BinOpKind::Gt => hir::BinOpKind::Gt,
  },
- span: b.span,
+ span,
  }
  }
 
@@ -1360,9 +1363,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
  body: &Block,
  opt_label: Option<Label>,
  ) -> hir::Expr<'hir> {
+ let orig_head_span = head.span;
  // expand <head>
  let mut head = self.lower_expr_mut(head);
- let desugared_span = self.mark_span_with_reason(DesugaringKind::ForLoop, head.span, None);
+ let desugared_span = self.mark_span_with_reason(
+ DesugaringKind::ForLoop(ForLoopLoc::Head),
+ orig_head_span,
+ None,
+ );
  head.span = desugared_span;
 
  let iter = Ident::with_dummy_span(sym::iter);
@@ -1457,10 +1465,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
  // `mut iter => { ... }`
  let iter_arm = self.arm(iter_pat, loop_expr);
 
+ let into_iter_span = self.mark_span_with_reason(
+ DesugaringKind::ForLoop(ForLoopLoc::IntoIter),
+ orig_head_span,
+ None,
+ );
+
  // `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
  let into_iter_expr = {
  let into_iter_path = &[sym::iter, sym::IntoIterator, sym::into_iter];
- self.expr_call_std_path(desugared_span, into_iter_path, arena_vec![self; head])
+ self.expr_call_std_path(into_iter_span, into_iter_path, arena_vec![self; head])
  };
 
  let match_expr = self.arena.alloc(self.expr_match(

src/librustc_error_codes/error_codes/E0446.md

@@ -4,10 +4,10 @@ Erroneous code example:
 
 ```compile_fail,E0446
 #![deny(private_in_public)]
+struct Bar(u32);
 
-mod Foo {
- struct Bar(u32);
-
+mod foo {
+ use crate::Bar;
  pub fn bar() -> Bar { // error: private type in public interface
  Bar(0)
  }
@@ -16,15 +16,31 @@ mod Foo {
 fn main() {}
 ```
 
-To solve this error, please ensure that the type is also public. The type
-can be made inaccessible if necessary by placing it into a private inner
-module, but it still has to be marked with `pub`.
+There are two ways to solve this error. The first is to make the public type
+signature only public to a module that also has access to the private type.
+This is done by using pub(crate) or pub(in crate::my_mod::etc)
 Example:
 
 ```
-mod Foo {
- pub struct Bar(u32); // we set the Bar type public
+struct Bar(u32);
+
+mod foo {
+ use crate::Bar;
+ pub(crate) fn bar() -> Bar { // only public to crate root
+ Bar(0)
+ }
+}
 
+fn main() {}
+```
+
+The other way to solve this error is to make the private type public.
+Example:
+
+```
+pub struct Bar(u32); // we set the Bar type public
+mod foo {
+ use crate::Bar;
  pub fn bar() -> Bar { // ok!
  Bar(0)
  }

src/librustc_error_codes/error_codes/E0493.md

@@ -1,5 +1,4 @@
-A type with a `Drop` implementation was destructured when trying to initialize
-a static item.
+A value with a custom `Drop` implementation may be dropped during const-eval.
 
 Erroneous code example:
 
@@ -16,13 +15,14 @@ struct Foo {
  field1: DropType,
 }
 
-static FOO: Foo = Foo { ..Foo { field1: DropType::A } }; // error!
+static FOO: Foo = Foo { field1: (DropType::A, DropType::A).1 }; // error!
 ```
 
 The problem here is that if the given type or one of its fields implements the
-`Drop` trait, this `Drop` implementation cannot be called during the static
-type initialization which might cause a memory leak. To prevent this issue,
-you need to instantiate all the static type's fields by hand.
+`Drop` trait, this `Drop` implementation cannot be called within a const
+context since it may run arbitrary, non-const-checked code. To prevent this
+issue, ensure all values with custom a custom `Drop` implementation escape the
+initializer.
 
 ```
 enum DropType {

src/librustc_feature/active.rs

@@ -577,6 +577,9 @@ declare_features! (
  /// Allows `extern "avr-interrupt" fn()` and `extern "avr-non-blocking-interrupt" fn()`.
  (active, abi_avr_interrupt, "1.45.0", Some(69664), None),
 
+ /// Be more precise when looking for live drops in a const context.
+ (active, const_precise_live_drops, "1.46.0", Some(73255), None),
+
  // -------------------------------------------------------------------------
  // feature-group-end: actual feature gates
  // -------------------------------------------------------------------------

src/librustc_infer/infer/error_reporting/need_type_info.rs

@@ -455,7 +455,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  let msg = if let Some(simple_ident) = pattern.simple_ident() {
  match pattern.span.desugaring_kind() {
  None => format!("consider giving `{}` {}", simple_ident, suffix),
- Some(DesugaringKind::ForLoop) => {
+ Some(DesugaringKind::ForLoop(_)) => {
  "the element type for this iterator is not specified".to_string()
  }
  _ => format!("this needs {}", suffix),

src/librustc_interface/passes.rs

@@ -847,7 +847,11 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
 
  sess.time("MIR_effect_checking", || {
  for def_id in tcx.body_owners() {
- mir::transform::check_unsafety::check_unsafety(tcx, def_id)
+ mir::transform::check_unsafety::check_unsafety(tcx, def_id);
+
+ if tcx.hir().body_const_context(def_id).is_some() {
+ tcx.ensure().mir_drops_elaborated_and_const_checked(def_id);
+ }
  }
  });
 

src/librustc_metadata/rmeta/decoder.rs

@@ -1315,13 +1315,13 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
  }
  }
 
- fn get_fn_param_names(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> &'tcx [Symbol] {
+ fn get_fn_param_names(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> &'tcx [Ident] {
  let param_names = match self.kind(id) {
  EntryKind::Fn(data) | EntryKind::ForeignFn(data) => data.decode(self).param_names,
  EntryKind::AssocFn(data) => data.decode(self).fn_data.param_names,
  _ => Lazy::empty(),
  };
- tcx.arena.alloc_from_iter(param_names.decode(self))
+ tcx.arena.alloc_from_iter(param_names.decode((self, tcx)))
  }
 
  fn exported_symbols(

src/librustc_metadata/rmeta/encoder.rs

@@ -30,7 +30,7 @@ use rustc_middle::ty::{self, SymbolName, Ty, TyCtxt};
 use rustc_serialize::{opaque, Encodable, Encoder, SpecializedEncoder};
 use rustc_session::config::CrateType;
 use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{kw, sym, Ident, Symbol};
+use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::{self, ExternalSource, FileName, SourceFile, Span};
 use rustc_target::abi::VariantIdx;
 use std::hash::Hash;
@@ -994,18 +994,12 @@ impl EncodeContext<'tcx> {
  }
  }
 
- fn encode_fn_param_names_for_body(&mut self, body_id: hir::BodyId) -> Lazy<[Symbol]> {
- self.tcx.dep_graph.with_ignore(|| {
- let body = self.tcx.hir().body(body_id);
- self.lazy(body.params.iter().map(|arg| match arg.pat.kind {
- hir::PatKind::Binding(_, _, ident, _) => ident.name,
- _ => kw::Invalid,
- }))
- })
+ fn encode_fn_param_names_for_body(&mut self, body_id: hir::BodyId) -> Lazy<[Ident]> {
+ self.tcx.dep_graph.with_ignore(|| self.lazy(self.tcx.hir().body_param_names(body_id)))
  }
 
- fn encode_fn_param_names(&mut self, param_names: &[Ident]) -> Lazy<[Symbol]> {
- self.lazy(param_names.iter().map(|ident| ident.name))
+ fn encode_fn_param_names(&mut self, param_names: &[Ident]) -> Lazy<[Ident]> {
+ self.lazy(param_names.iter())
  }
 
  fn encode_optimized_mir(&mut self, def_id: LocalDefId) {

src/librustc_metadata/rmeta/mod.rs

@@ -19,7 +19,7 @@ use rustc_serialize::opaque::Encoder;
 use rustc_session::config::SymbolManglingVersion;
 use rustc_session::CrateDisambiguator;
 use rustc_span::edition::Edition;
-use rustc_span::symbol::Symbol;
+use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::{self, Span};
 use rustc_target::spec::{PanicStrategy, TargetTriple};
 
@@ -326,7 +326,7 @@ struct ModData {
 struct FnData {
  asyncness: hir::IsAsync,
  constness: hir::Constness,
- param_names: Lazy<[Symbol]>,
+ param_names: Lazy<[Ident]>,
 }
 
 #[derive(RustcEncodable, RustcDecodable)]

src/librustc_middle/hir/map/mod.rs

@@ -14,7 +14,7 @@ use rustc_hir::*;
 use rustc_index::vec::IndexVec;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{kw, Symbol};
+use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::Span;
 use rustc_target::spec::abi::Abi;
 
@@ -374,6 +374,13 @@ impl<'hir> Map<'hir> {
  })
  }
 
+ pub fn body_param_names(&self, id: BodyId) -> impl Iterator<Item = Ident> + 'hir {
+ self.body(id).params.iter().map(|arg| match arg.pat.kind {
+ PatKind::Binding(_, _, ident, _) => ident,
+ _ => Ident::new(kw::Invalid, rustc_span::DUMMY_SP),
+ })
+ }
+
  /// Returns the `BodyOwnerKind` of this `LocalDefId`.
  ///
  /// Panics if `LocalDefId` does not have an associated body.