Auto merge of rust-lang#129994 - matthiaskrgr:rollup-zkj4ekl, r=matth…

…iaskrgr

Rollup of 8 pull requests

Successful merges:

 - rust-lang#128820 (fix: get llvm type of global val)
 - rust-lang#129028 (`impl_trait_overcaptures`: Don't worry about uncaptured contravariant lifetimes if they outlive a captured lifetime)
 - rust-lang#129471 ([rustdoc] Sort impl associated items by kinds and then by appearance)
 - rust-lang#129706 (Rename dump of coroutine by-move-body to be more consistent, fix ICE in dump_mir)
 - rust-lang#129720 (Simplify DestProp memory management)
 - rust-lang#129796 (Unify scraped examples with other code examples)
 - rust-lang#129938 (Elaborate on deriving vs implementing `Copy`)
 - rust-lang#129973 (run_make_support: rename `Command::stdin` to `stdin_buf` and add `std{in,out,err}` config helpers)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_codegen_llvm/src/consts.rs

@@ -390,7 +390,7 @@ impl<'ll> CodegenCx<'ll, '_> {
  let val_llty = self.val_ty(v);
 
  let g = self.get_static_inner(def_id, val_llty);
- let llty = self.val_ty(g);
+ let llty = llvm::LLVMGlobalGetValueType(g);
 
  let g = if val_llty == llty {
  g

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -974,6 +974,7 @@ unsafe extern "C" {
  pub fn LLVMGetAlignment(Global: &Value) -> c_uint;
  pub fn LLVMSetAlignment(Global: &Value, Bytes: c_uint);
  pub fn LLVMSetDLLStorageClass(V: &Value, C: DLLStorageClass);
+ pub fn LLVMGlobalGetValueType(Global: &Value) -> &Type;
 
  // Operations on global variables
  pub fn LLVMIsAGlobalVariable(GlobalVar: &Value) -> Option<&Value>;

compiler/rustc_lint/src/lib.rs

@@ -30,6 +30,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(array_windows)]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(extract_if)]

compiler/rustc_middle/src/mir/pretty.rs

@@ -612,7 +612,9 @@ fn write_mir_sig(tcx: TyCtxt<'_>, body: &Body<'_>, w: &mut dyn io::Write) -> io:
  let def_id = body.source.def_id();
  let kind = tcx.def_kind(def_id);
  let is_function = match kind {
- DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) => true,
+ DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) | DefKind::SyntheticCoroutineBody => {
+ true
+ }
  _ => tcx.is_closure_like(def_id),
  };
  match (kind, body.source.promoted) {

compiler/rustc_mir_transform/src/coroutine/by_move_body.rs

@@ -207,11 +207,12 @@ pub fn coroutine_by_move_body_def_id<'tcx>(
 
  let mut by_move_body = body.clone();
  MakeByMoveBody { tcx, field_remapping, by_move_coroutine_ty }.visit_body(&mut by_move_body);
- dump_mir(tcx, false, "coroutine_by_move", &0, &by_move_body, |_, _| Ok(()));
 
- let body_def = tcx.create_def(coroutine_def_id, kw::Empty, DefKind::SyntheticCoroutineBody);
+ // This will always be `{closure#1}`, since the original coroutine is `{closure#0}`.
+ let body_def = tcx.create_def(parent_def_id, kw::Empty, DefKind::SyntheticCoroutineBody);
  by_move_body.source =
  mir::MirSource::from_instance(InstanceKind::Item(body_def.def_id().to_def_id()));
+ dump_mir(tcx, false, "built", &"after", &by_move_body, |_, _| Ok(()));
 
  // Inherited from the by-ref coroutine.
  body_def.codegen_fn_attrs(tcx.codegen_fn_attrs(coroutine_def_id).clone());

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -163,7 +163,8 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
 
  fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
  let def_id = body.source.def_id();
- let mut allocations = Allocations::default();
+ let mut candidates = Candidates::default();
+ let mut write_info = WriteInfo::default();
  trace!(func = ?tcx.def_path_str(def_id));
 
  let borrowed = rustc_mir_dataflow::impls::borrowed_locals(body);
@@ -191,20 +192,15 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
  loop {
  // PERF: Can we do something smarter than recalculating the candidates and liveness
  // results?
- let mut candidates = find_candidates(
- body,
- &borrowed,
- &mut allocations.candidates,
- &mut allocations.candidates_reverse,
- );
+ candidates.reset_and_find(body, &borrowed);
  trace!(?candidates);
  dest_prop_mir_dump(tcx, body, &points, &live, round_count);
 
  FilterInformation::filter_liveness(
  &mut candidates,
  &points,
  &live,
- &mut allocations.write_info,
+ &mut write_info,
  body,
  );
 
@@ -253,20 +249,8 @@ impl<'tcx> crate::MirPass<'tcx> for DestinationPropagation {
  }
 }
 
-/// Container for the various allocations that we need.
-///
-/// We store these here and hand out `&mut` access to them, instead of dropping and recreating them
-/// frequently. Everything with a `&'alloc` lifetime points into here.
-#[derive(Default)]
-struct Allocations {
- candidates: FxIndexMap<Local, Vec<Local>>,
- candidates_reverse: FxIndexMap<Local, Vec<Local>>,
- write_info: WriteInfo,
- // PERF: Do this for `MaybeLiveLocals` allocations too.
-}
-
-#[derive(Debug)]
-struct Candidates<'alloc> {
+#[derive(Debug, Default)]
+struct Candidates {
  /// The set of candidates we are considering in this optimization.
  ///
  /// We will always merge the key into at most one of its values.
@@ -281,11 +265,12 @@ struct Candidates<'alloc> {
  ///
  /// We will still report that we would like to merge `_1` and `_2` in an attempt to allow us to
  /// remove that assignment.
- c: &'alloc mut FxIndexMap<Local, Vec<Local>>,
+ c: FxIndexMap<Local, Vec<Local>>,
+
  /// A reverse index of the `c` set; if the `c` set contains `a => Place { local: b, proj }`,
  /// then this contains `b => a`.
  // PERF: Possibly these should be `SmallVec`s?
- reverse: &'alloc mut FxIndexMap<Local, Vec<Local>>,
+ reverse: FxIndexMap<Local, Vec<Local>>,
 }
 
 //////////////////////////////////////////////////////////
@@ -358,19 +343,40 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Merger<'a, 'tcx> {
 //
 // This section enforces bullet point 2
 
-struct FilterInformation<'a, 'body, 'alloc, 'tcx> {
- body: &'body Body<'tcx>,
+struct FilterInformation<'a, 'tcx> {
+ body: &'a Body<'tcx>,
  points: &'a DenseLocationMap,
  live: &'a SparseIntervalMatrix<Local, PointIndex>,
- candidates: &'a mut Candidates<'alloc>,
- write_info: &'alloc mut WriteInfo,
+ candidates: &'a mut Candidates,
+ write_info: &'a mut WriteInfo,
  at: Location,
 }
 
 // We first implement some utility functions which we will expose removing candidates according to
 // different needs. Throughout the liveness filtering, the `candidates` are only ever accessed
 // through these methods, and not directly.
-impl<'alloc> Candidates<'alloc> {
+impl Candidates {
+ /// Collects the candidates for merging.
+ ///
+ /// This is responsible for enforcing the first and third bullet point.
+ fn reset_and_find<'tcx>(&mut self, body: &Body<'tcx>, borrowed: &BitSet<Local>) {
+ self.c.clear();
+ self.reverse.clear();
+ let mut visitor = FindAssignments { body, candidates: &mut self.c, borrowed };
+ visitor.visit_body(body);
+ // Deduplicate candidates.
+ for (_, cands) in self.c.iter_mut() {
+ cands.sort();
+ cands.dedup();
+ }
+ // Generate the reverse map.
+ for (src, cands) in self.c.iter() {
+ for dest in cands.iter().copied() {
+ self.reverse.entry(dest).or_default().push(*src);
+ }
+ }
+ }
+
  /// Just `Vec::retain`, but the condition is inverted and we add debugging output
  fn vec_filter_candidates(
  src: Local,
@@ -445,7 +451,7 @@ enum CandidateFilter {
  Remove,
 }
 
-impl<'a, 'body, 'alloc, 'tcx> FilterInformation<'a, 'body, 'alloc, 'tcx> {
+impl<'a, 'tcx> FilterInformation<'a, 'tcx> {
  /// Filters the set of candidates to remove those that conflict.
  ///
  /// The steps we take are exactly those that are outlined at the top of the file. For each
@@ -463,12 +469,12 @@ impl<'a, 'body, 'alloc, 'tcx> FilterInformation<'a, 'body, 'alloc, 'tcx> {
  /// before the statement/terminator will correctly report locals that are read in the
  /// statement/terminator to be live. We are additionally conservative by treating all written to
  /// locals as also being read from.
- fn filter_liveness<'b>(
- candidates: &mut Candidates<'alloc>,
+ fn filter_liveness(
+ candidates: &mut Candidates,
  points: &DenseLocationMap,
  live: &SparseIntervalMatrix<Local, PointIndex>,
- write_info_alloc: &'alloc mut WriteInfo,
- body: &'b Body<'tcx>,
+ write_info: &mut WriteInfo,
+ body: &Body<'tcx>,
  ) {
  let mut this = FilterInformation {
  body,
@@ -477,7 +483,7 @@ impl<'a, 'body, 'alloc, 'tcx> FilterInformation<'a, 'body, 'alloc, 'tcx> {
  candidates,
  // We don't actually store anything at this scope, we just keep things here to be able
  // to reuse the allocation.
- write_info: write_info_alloc,
+ write_info,
  // Doesn't matter what we put here, will be overwritten before being used
  at: Location::START,
  };
@@ -734,40 +740,13 @@ fn places_to_candidate_pair<'tcx>(
  Some((a, b))
 }
 
-/// Collects the candidates for merging
-///
-/// This is responsible for enforcing the first and third bullet point.
-fn find_candidates<'alloc, 'tcx>(
- body: &Body<'tcx>,
- borrowed: &BitSet<Local>,
- candidates: &'alloc mut FxIndexMap<Local, Vec<Local>>,
- candidates_reverse: &'alloc mut FxIndexMap<Local, Vec<Local>>,
-) -> Candidates<'alloc> {
- candidates.clear();
- candidates_reverse.clear();
- let mut visitor = FindAssignments { body, candidates, borrowed };
- visitor.visit_body(body);
- // Deduplicate candidates
- for (_, cands) in candidates.iter_mut() {
- cands.sort();
- cands.dedup();
- }
- // Generate the reverse map
- for (src, cands) in candidates.iter() {
- for dest in cands.iter().copied() {
- candidates_reverse.entry(dest).or_default().push(*src);
- }
- }
- Candidates { c: candidates, reverse: candidates_reverse }
-}
-
-struct FindAssignments<'a, 'alloc, 'tcx> {
+struct FindAssignments<'a, 'tcx> {
  body: &'a Body<'tcx>,
- candidates: &'alloc mut FxIndexMap<Local, Vec<Local>>,
+ candidates: &'a mut FxIndexMap<Local, Vec<Local>>,
  borrowed: &'a BitSet<Local>,
 }
 
-impl<'tcx> Visitor<'tcx> for FindAssignments<'_, '_, 'tcx> {
+impl<'tcx> Visitor<'tcx> for FindAssignments<'_, 'tcx> {
  fn visit_statement(&mut self, statement: &Statement<'tcx>, _: Location) {
  if let StatementKind::Assign(box (
  lhs,
@@ -819,9 +798,9 @@ fn is_local_required(local: Local, body: &Body<'_>) -> bool {
 /////////////////////////////////////////////////////////
 // MIR Dump
 
-fn dest_prop_mir_dump<'body, 'tcx>(
+fn dest_prop_mir_dump<'tcx>(
  tcx: TyCtxt<'tcx>,
- body: &'body Body<'tcx>,
+ body: &Body<'tcx>,
  points: &DenseLocationMap,
  live: &SparseIntervalMatrix<Local, PointIndex>,
  round: usize,

library/core/src/marker.rs

@@ -288,8 +288,19 @@ marker_impls! {
 /// }
 /// ```
 ///
-/// There is a small difference between the two: the `derive` strategy will also place a `Copy`
-/// bound on type parameters, which isn't always desired.
+/// There is a small difference between the two. The `derive` strategy will also place a `Copy`
+/// bound on type parameters:
+///
+/// ```
+/// #[derive(Clone)]
+/// struct MyStruct<T>(T);
+///
+/// impl<T: Copy> Copy for MyStruct<T> { }
+/// ```
+///
+/// This isn't always desired. For example, shared references (`&T`) can be copied regardless of
+/// whether `T` is `Copy`. Likewise, a generic struct containing markers such as [`PhantomData`]
+/// could potentially be duplicated with a bit-wise copy.
 ///
 /// ## What's the difference between `Copy` and `Clone`?
 ///

src/librustdoc/html/render/mod.rs

@@ -1794,13 +1794,64 @@ fn render_impl(
  let mut default_impl_items = Buffer::empty_from(w);
  let impl_ = i.inner_impl();
 
+ // Impl items are grouped by kinds:
+ //
+ // 1. Constants
+ // 2. Types
+ // 3. Functions
+ //
+ // This order is because you can have associated constants used in associated types (like array
+ // length), and both in associcated functions. So with this order, when reading from top to
+ // bottom, you should see items definitions before they're actually used most of the time.
+ let mut assoc_types = Vec::new();
+ let mut methods = Vec::new();
+
  if !impl_.is_negative_trait_impl() {
  for trait_item in &impl_.items {
+ match *trait_item.kind {
+ clean::MethodItem(..) | clean::TyMethodItem(_) => methods.push(trait_item),
+ clean::TyAssocTypeItem(..) | clean::AssocTypeItem(..) => {
+ assoc_types.push(trait_item)
+ }
+ clean::TyAssocConstItem(..) | clean::AssocConstItem(_) => {
+ // We render it directly since they're supposed to come first.
+ doc_impl_item(
+ &mut default_impl_items,
+ &mut impl_items,
+ cx,
+ trait_item,
+ if trait_.is_some() { &i.impl_item } else { parent },
+ link,
+ render_mode,
+ false,
+ trait_,
+ rendering_params,
+ );
+ }
+ _ => {}
+ }
+ }
+
+ for assoc_type in assoc_types {
  doc_impl_item(
  &mut default_impl_items,
  &mut impl_items,
  cx,
- trait_item,
+ assoc_type,
+ if trait_.is_some() { &i.impl_item } else { parent },
+ link,
+ render_mode,
+ false,
+ trait_,
+ rendering_params,
+ );
+ }
+ for method in methods {
+ doc_impl_item(
+ &mut default_impl_items,
+ &mut impl_items,
+ cx,
+ method,
  if trait_.is_some() { &i.impl_item } else { parent },
  link,
  render_mode,
@@ -2455,28 +2506,6 @@ fn render_call_locations<W: fmt::Write>(mut w: W, cx: &mut Context<'_>, item: &c
  let needs_expansion = line_max - line_min > NUM_VISIBLE_LINES;
  let locations_encoded = serde_json::to_string(&line_ranges).unwrap();
 
- write!(
- &mut w,
- "<div class=\"scraped-example {expanded_cls}\" data-locs=\"{locations}\">\
- <div class=\"scraped-example-title\">\
- {name} (<a href=\"{url}\">{title}</a>)\
- </div>\
- <div class=\"code-wrapper\">",
- expanded_cls = if needs_expansion { "" } else { "expanded" },
- name = call_data.display_name,
- url = init_url,
- title = init_title,
- // The locations are encoded as a data attribute, so they can be read
- // later by the JS for interactions.
- locations = Escape(&locations_encoded)
- )
- .unwrap();
-
- if line_ranges.len() > 1 {
- w.write_str(r#"<button class="prev">&pr;</button> <button class="next">&sc;</button>"#)
- .unwrap();
- }
-
  // Look for the example file in the source map if it exists, otherwise return a dummy span
  let file_span = (|| {
  let source_map = tcx.sess.source_map();
@@ -2507,9 +2536,16 @@ fn render_call_locations<W: fmt::Write>(mut w: W, cx: &mut Context<'_>, item: &c
  cx,
  &cx.root_path(),
  highlight::DecorationInfo(decoration_info),
- sources::SourceContext::Embedded { offset: line_min, needs_expansion },
+ sources::SourceContext::Embedded(sources::ScrapedInfo {
+ needs_prev_next_buttons: line_ranges.len() > 1,
+ needs_expansion,
+ offset: line_min,
+ name: &call_data.display_name,
+ url: init_url,
+ title: init_title,
+ locations: locations_encoded,
+ }),
  );
- w.write_str("</div></div>").unwrap();
 
  true
  };