Auto merge of #125414 - fmease:rollup-1vkam42, r=fmease

Rollup of 7 pull requests Successful merges: - #125043 (reference type safety invariant docs: clarification) - #125306 (Force the inner coroutine of an async closure to `move` if the outer closure is `move` and `FnOnce`) - #125355 (Use Backtrace::force_capture instead of Backtrace::capture in rustc_log) - #125378 (remove tracing tree indent lines) - #125391 (Minor serialize/span tweaks) - #125395 (Remove unnecessary `.md` from the documentation sidebar) - #125399 (Stop using `to_hir_binop` in codegen) r? `@ghost` `@rustbot` modify labels: rollup

Author: bors

compiler/rustc_codegen_gcc/src/intrinsic/simd.rs

@@ -14,6 +14,7 @@ use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{BaseTypeMethods, BuilderMethods};
 use rustc_hir as hir;
+use rustc_middle::mir::BinOp;
 use rustc_middle::span_bug;
 use rustc_middle::ty::layout::HasTyCtxt;
 use rustc_middle::ty::{self, Ty};
@@ -122,12 +123,12 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
  let in_ty = arg_tys[0];
 
  let comparison = match name {
- sym::simd_eq => Some(hir::BinOpKind::Eq),
- sym::simd_ne => Some(hir::BinOpKind::Ne),
- sym::simd_lt => Some(hir::BinOpKind::Lt),
- sym::simd_le => Some(hir::BinOpKind::Le),
- sym::simd_gt => Some(hir::BinOpKind::Gt),
- sym::simd_ge => Some(hir::BinOpKind::Ge),
+ sym::simd_eq => Some(BinOp::Eq),
+ sym::simd_ne => Some(BinOp::Ne),
+ sym::simd_lt => Some(BinOp::Lt),
+ sym::simd_le => Some(BinOp::Le),
+ sym::simd_gt => Some(BinOp::Gt),
+ sym::simd_ge => Some(BinOp::Ge),
  _ => None,
  };
 

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -14,6 +14,7 @@ use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::*;
 use rustc_hir as hir;
+use rustc_middle::mir::BinOp;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, LayoutOf};
 use rustc_middle::ty::{self, GenericArgsRef, Ty};
 use rustc_middle::{bug, span_bug};
@@ -1104,12 +1105,12 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
  let in_ty = arg_tys[0];
 
  let comparison = match name {
- sym::simd_eq => Some(hir::BinOpKind::Eq),
- sym::simd_ne => Some(hir::BinOpKind::Ne),
- sym::simd_lt => Some(hir::BinOpKind::Lt),
- sym::simd_le => Some(hir::BinOpKind::Le),
- sym::simd_gt => Some(hir::BinOpKind::Gt),
- sym::simd_ge => Some(hir::BinOpKind::Ge),
+ sym::simd_eq => Some(BinOp::Eq),
+ sym::simd_ne => Some(BinOp::Ne),
+ sym::simd_lt => Some(BinOp::Lt),
+ sym::simd_le => Some(BinOp::Le),
+ sym::simd_gt => Some(BinOp::Gt),
+ sym::simd_ge => Some(BinOp::Ge),
  _ => None,
  };
 

compiler/rustc_codegen_ssa/src/base.rs

@@ -20,7 +20,6 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
 use rustc_data_structures::sync::par_map;
 use rustc_data_structures::unord::UnordMap;
-use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_hir::lang_items::LangItem;
 use rustc_metadata::EncodedMetadata;
@@ -30,6 +29,7 @@ use rustc_middle::middle::debugger_visualizer::{DebuggerVisualizerFile, Debugger
 use rustc_middle::middle::exported_symbols;
 use rustc_middle::middle::exported_symbols::SymbolExportKind;
 use rustc_middle::middle::lang_items;
+use rustc_middle::mir::BinOp;
 use rustc_middle::mir::mono::{CodegenUnit, CodegenUnitNameBuilder, MonoItem};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
@@ -46,32 +46,32 @@ use std::time::{Duration, Instant};
 
 use itertools::Itertools;
 
-pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind, signed: bool) -> IntPredicate {
+pub fn bin_op_to_icmp_predicate(op: BinOp, signed: bool) -> IntPredicate {
  match op {
- hir::BinOpKind::Eq => IntPredicate::IntEQ,
- hir::BinOpKind::Ne => IntPredicate::IntNE,
- hir::BinOpKind::Lt => {
+ BinOp::Eq => IntPredicate::IntEQ,
+ BinOp::Ne => IntPredicate::IntNE,
+ BinOp::Lt => {
  if signed {
  IntPredicate::IntSLT
  } else {
  IntPredicate::IntULT
  }
  }
- hir::BinOpKind::Le => {
+ BinOp::Le => {
  if signed {
  IntPredicate::IntSLE
  } else {
  IntPredicate::IntULE
  }
  }
- hir::BinOpKind::Gt => {
+ BinOp::Gt => {
  if signed {
  IntPredicate::IntSGT
  } else {
  IntPredicate::IntUGT
  }
  }
- hir::BinOpKind::Ge => {
+ BinOp::Ge => {
  if signed {
  IntPredicate::IntSGE
  } else {
@@ -86,14 +86,14 @@ pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind, signed: bool) -> IntPredicat
  }
 }
 
-pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> RealPredicate {
+pub fn bin_op_to_fcmp_predicate(op: BinOp) -> RealPredicate {
  match op {
- hir::BinOpKind::Eq => RealPredicate::RealOEQ,
- hir::BinOpKind::Ne => RealPredicate::RealUNE,
- hir::BinOpKind::Lt => RealPredicate::RealOLT,
- hir::BinOpKind::Le => RealPredicate::RealOLE,
- hir::BinOpKind::Gt => RealPredicate::RealOGT,
- hir::BinOpKind::Ge => RealPredicate::RealOGE,
+ BinOp::Eq => RealPredicate::RealOEQ,
+ BinOp::Ne => RealPredicate::RealUNE,
+ BinOp::Lt => RealPredicate::RealOLT,
+ BinOp::Le => RealPredicate::RealOLE,
+ BinOp::Gt => RealPredicate::RealOGT,
+ BinOp::Ge => RealPredicate::RealOGE,
  op => {
  bug!(
  "comparison_op_to_fcmp_predicate: expected comparison operator, \
@@ -110,7 +110,7 @@ pub fn compare_simd_types<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
  rhs: Bx::Value,
  t: Ty<'tcx>,
  ret_ty: Bx::Type,
- op: hir::BinOpKind,
+ op: BinOp,
 ) -> Bx::Value {
  let signed = match t.kind() {
  ty::Float(_) => {

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -7,7 +7,6 @@ use crate::common::IntPredicate;
 use crate::traits::*;
 use crate::MemFlags;
 
-use rustc_hir as hir;
 use rustc_middle::mir;
 use rustc_middle::ty::cast::{CastTy, IntTy};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
@@ -896,9 +895,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  | mir::BinOp::Le
  | mir::BinOp::Ge => {
  if is_float {
- bx.fcmp(base::bin_op_to_fcmp_predicate(op.to_hir_binop()), lhs, rhs)
+ bx.fcmp(base::bin_op_to_fcmp_predicate(op), lhs, rhs)
  } else {
- bx.icmp(base::bin_op_to_icmp_predicate(op.to_hir_binop(), is_signed), lhs, rhs)
+ bx.icmp(base::bin_op_to_icmp_predicate(op, is_signed), lhs, rhs)
  }
  }
  mir::BinOp::Cmp => {
@@ -912,16 +911,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  // `PartialOrd`, so only use it in debug for now. Once LLVM can handle it
  // better (see <https://github.com/llvm/llvm-project/issues/73417>), it'll
  // be worth trying it in optimized builds as well.
- let is_gt = bx.icmp(pred(hir::BinOpKind::Gt), lhs, rhs);
+ let is_gt = bx.icmp(pred(mir::BinOp::Gt), lhs, rhs);
  let gtext = bx.zext(is_gt, bx.type_i8());
- let is_lt = bx.icmp(pred(hir::BinOpKind::Lt), lhs, rhs);
+ let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
  let ltext = bx.zext(is_lt, bx.type_i8());
  bx.unchecked_ssub(gtext, ltext)
  } else {
  // These operations are those expected by `tests/codegen/integer-cmp.rs`,
  // from <https://github.com/rust-lang/rust/pull/63767>.
- let is_lt = bx.icmp(pred(hir::BinOpKind::Lt), lhs, rhs);
- let is_ne = bx.icmp(pred(hir::BinOpKind::Ne), lhs, rhs);
+ let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
+ let is_ne = bx.icmp(pred(mir::BinOp::Ne), lhs, rhs);
  let ge = bx.select(
  is_ne,
  bx.cx().const_i8(Ordering::Greater as i8),

compiler/rustc_hir_typeck/src/upvar.rs

@@ -204,6 +204,60 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  fake_reads: Default::default(),
  };
 
+ let _ = euv::ExprUseVisitor::new(
+ &FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
+ &mut delegate,
+ )
+ .consume_body(body);
+
+ // There are several curious situations with coroutine-closures where
+ // analysis is too aggressive with borrows when the coroutine-closure is
+ // marked `move`. Specifically:
+ //
+ // 1. If the coroutine-closure was inferred to be `FnOnce` during signature
+ // inference, then it's still possible that we try to borrow upvars from
+ // the coroutine-closure because they are not used by the coroutine body
+ // in a way that forces a move. See the test:
+ // `async-await/async-closures/force-move-due-to-inferred-kind.rs`.
+ //
+ // 2. If the coroutine-closure is forced to be `FnOnce` due to the way it
+ // uses its upvars, but not *all* upvars would force the closure to `FnOnce`.
+ // See the test: `async-await/async-closures/force-move-due-to-actually-fnonce.rs`.
+ //
+ // This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
+ // coroutine bodies can't borrow from their parent closure. To fix this,
+ // we force the inner coroutine to also be `move`. This only matters for
+ // coroutine-closures that are `move` since otherwise they themselves will
+ // be borrowing from the outer environment, so there's no self-borrows occuring.
+ //
+ // One *important* note is that we do a call to `process_collected_capture_information`
+ // to eagerly test whether the coroutine would end up `FnOnce`, but we do this
+ // *before* capturing all the closure args by-value below, since that would always
+ // cause the analysis to return `FnOnce`.
+ if let UpvarArgs::Coroutine(..) = args
+ && let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
+ self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
+ && let parent_hir_id =
+ self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
+ && let parent_ty = self.node_ty(parent_hir_id)
+ && let hir::CaptureBy::Value { move_kw } =
+ self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause
+ {
+ // (1.) Closure signature inference forced this closure to `FnOnce`.
+ if let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty) {
+ capture_clause = hir::CaptureBy::Value { move_kw };
+ }
+ // (2.) The way that the closure uses its upvars means it's `FnOnce`.
+ else if let (_, ty::ClosureKind::FnOnce, _) = self
+ .process_collected_capture_information(
+ capture_clause,
+ &delegate.capture_information,
+ )
+ {
+ capture_clause = hir::CaptureBy::Value { move_kw };
+ }
+ }
+
  // As noted in `lower_coroutine_body_with_moved_arguments`, we default the capture mode
  // to `ByRef` for the `async {}` block internal to async fns/closure. This means
  // that we would *not* be moving all of the parameters into the async block by default.
@@ -253,34 +307,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
  }
 
- let _ = euv::ExprUseVisitor::new(
- &FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
- &mut delegate,
- )
- .consume_body(body);
-
- // If a coroutine is comes from a coroutine-closure that is `move`, but
- // the coroutine-closure was inferred to be `FnOnce` during signature
- // inference, then it's still possible that we try to borrow upvars from
- // the coroutine-closure because they are not used by the coroutine body
- // in a way that forces a move.
- //
- // This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
- // coroutine bodies can't borrow from their parent closure. To fix this,
- // we force the inner coroutine to also be `move`. This only matters for
- // coroutine-closures that are `move` since otherwise they themselves will
- // be borrowing from the outer environment, so there's no self-borrows occuring.
- if let UpvarArgs::Coroutine(..) = args
- && let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
- self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
- && let parent_hir_id =
- self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
- && let parent_ty = self.node_ty(parent_hir_id)
- && let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty)
- {
- capture_clause = self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause;
- }
-
  debug!(
  "For closure={:?}, capture_information={:#?}",
  closure_def_id, delegate.capture_information
@@ -289,7 +315,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  self.log_capture_analysis_first_pass(closure_def_id, &delegate.capture_information, span);
 
  let (capture_information, closure_kind, origin) = self
- .process_collected_capture_information(capture_clause, delegate.capture_information);
+ .process_collected_capture_information(capture_clause, &delegate.capture_information);
 
  self.compute_min_captures(closure_def_id, capture_information, span);
 
@@ -545,13 +571,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  fn process_collected_capture_information(
  &self,
  capture_clause: hir::CaptureBy,
- capture_information: InferredCaptureInformation<'tcx>,
+ capture_information: &InferredCaptureInformation<'tcx>,
  ) -> (InferredCaptureInformation<'tcx>, ty::ClosureKind, Option<(Span, Place<'tcx>)>) {
  let mut closure_kind = ty::ClosureKind::LATTICE_BOTTOM;
  let mut origin: Option<(Span, Place<'tcx>)> = None;
 
  let processed = capture_information
- .into_iter()
+ .iter()
+ .cloned()
  .map(|(place, mut capture_info)| {
  // Apply rules for safety before inferring closure kind
  let (place, capture_kind) =

compiler/rustc_log/src/lib.rs

@@ -103,7 +103,6 @@ pub fn init_logger(cfg: LoggerConfig) -> Result<(), Error> {
 
  let mut layer = tracing_tree::HierarchicalLayer::default()
  .with_writer(io::stderr)
- .with_indent_lines(true)
  .with_ansi(color_logs)
  .with_targets(true)
  .with_verbose_exit(verbose_entry_exit)
@@ -159,7 +158,9 @@ where
  if !target.contains(&self.backtrace_target) {
  return Ok(());
  }
- let backtrace = std::backtrace::Backtrace::capture();
+ // Use Backtrace::force_capture because we don't want to depend on the
+ // RUST_BACKTRACE environment variable being set.
+ let backtrace = std::backtrace::Backtrace::force_capture();
  writeln!(writer, "stack backtrace: \n{backtrace:?}")
  }
 }

compiler/rustc_macros/src/serialize.rs

@@ -13,7 +13,7 @@ pub fn type_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2:
  quote! {}
  };
 
- s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_type_ir::codec::TyDecoder #bound });
+ s.add_impl_generic(parse_quote! { #decoder_ty: ::rustc_type_ir::codec::TyDecoder #bound });
  s.add_bounds(synstructure::AddBounds::Fields);
  s.underscore_const(true);
 
@@ -34,7 +34,7 @@ pub fn meta_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2:
 
 pub fn decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
  let decoder_ty = quote! { __D };
- s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_span::SpanDecoder});
+ s.add_impl_generic(parse_quote! { #decoder_ty: ::rustc_span::SpanDecoder });
  s.add_bounds(synstructure::AddBounds::Generics);
  s.underscore_const(true);
 
@@ -43,7 +43,7 @@ pub fn decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::Toke
 
 pub fn decodable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
  let decoder_ty = quote! { __D };
- s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_serialize::Decoder});
+ s.add_impl_generic(parse_quote! { #decoder_ty: ::rustc_serialize::Decoder });
  s.add_bounds(synstructure::AddBounds::Generics);
  s.underscore_const(true);
 
@@ -120,7 +120,7 @@ fn decode_field(field: &syn::Field) -> proc_macro2::TokenStream {
  let __decoder = quote! { __decoder };
  // Use the span of the field for the method call, so
  // that backtraces will point to the field.
- quote_spanned! {field_span=> #decode_inner_method(#__decoder) }
+ quote_spanned! { field_span=> #decode_inner_method(#__decoder) }
 }
 
 pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
@@ -133,7 +133,7 @@ pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2:
  };
 
  let encoder_ty = quote! { __E };
- s.add_impl_generic(parse_quote! {#encoder_ty: ::rustc_type_ir::codec::TyEncoder #bound });
+ s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_type_ir::codec::TyEncoder #bound });
  s.add_bounds(synstructure::AddBounds::Fields);
  s.underscore_const(true);
 
@@ -142,7 +142,7 @@ pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2:
 
 pub fn meta_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
  if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
- s.add_impl_generic(parse_quote! {'tcx});
+ s.add_impl_generic(parse_quote! { 'tcx });
  }
  s.add_impl_generic(parse_quote! { '__a });
  let encoder_ty = quote! { EncodeContext<'__a, 'tcx> };
@@ -154,7 +154,7 @@ pub fn meta_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2:
 
 pub fn encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
  let encoder_ty = quote! { __E };
- s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_span::SpanEncoder});
+ s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_span::SpanEncoder });
  s.add_bounds(synstructure::AddBounds::Generics);
  s.underscore_const(true);
 
@@ -163,7 +163,7 @@ pub fn encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::Toke
 
 pub fn encodable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
  let encoder_ty = quote! { __E };
- s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_serialize::Encoder});
+ s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_serialize::Encoder });
  s.add_bounds(synstructure::AddBounds::Generics);
  s.underscore_const(true);