Rollup merge of #105870 - matthiaskrgr:useless_conv, r=oli-obk

avoid .into() conversion to identical types

compiler/rustc_builtin_macros/src/test.rs

@@ -239,8 +239,7 @@ pub fn expand_test_or_bench(
  cx.attr_nested_word(sym::cfg, sym::test, attr_sp),
  // #[rustc_test_marker = "test_case_sort_key"]
  cx.attr_name_value_str(sym::rustc_test_marker, test_path_symbol, attr_sp),
- ]
- .into(),
+ ],
  // const $ident: test::TestDescAndFn =
  ast::ItemKind::Const(
  ast::Defaultness::Final,

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -39,7 +39,7 @@ pub enum Immediate<Prov: Provenance = AllocId> {
 impl<Prov: Provenance> From<Scalar<Prov>> for Immediate<Prov> {
  #[inline(always)]
  fn from(val: Scalar<Prov>) -> Self {
- Immediate::Scalar(val.into())
+ Immediate::Scalar(val)
  }
 }
 
@@ -53,15 +53,15 @@ impl<Prov: Provenance> Immediate<Prov> {
  }
 
  pub fn new_slice(val: Scalar<Prov>, len: u64, cx: &impl HasDataLayout) -> Self {
- Immediate::ScalarPair(val.into(), Scalar::from_machine_usize(len, cx).into())
+ Immediate::ScalarPair(val, Scalar::from_machine_usize(len, cx))
  }
 
  pub fn new_dyn_trait(
  val: Scalar<Prov>,
  vtable: Pointer<Option<Prov>>,
  cx: &impl HasDataLayout,
  ) -> Self {
- Immediate::ScalarPair(val.into(), Scalar::from_maybe_pointer(vtable, cx))
+ Immediate::ScalarPair(val, Scalar::from_maybe_pointer(vtable, cx))
  }
 
  #[inline]
@@ -341,10 +341,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  alloc_range(b_offset, b_size),
  /*read_provenance*/ b.is_ptr(),
  )?;
- Some(ImmTy {
- imm: Immediate::ScalarPair(a_val.into(), b_val.into()),
- layout: mplace.layout,
- })
+ Some(ImmTy { imm: Immediate::ScalarPair(a_val, b_val), layout: mplace.layout })
  }
  _ => {
  // Neither a scalar nor scalar pair.

compiler/rustc_const_eval/src/interpret/operator.rs

@@ -36,7 +36,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  if let Abi::ScalarPair(..) = dest.layout.abi {
  // We can use the optimized path and avoid `place_field` (which might do
  // `force_allocation`).
- let pair = Immediate::ScalarPair(val.into(), Scalar::from_bool(overflowed).into());
+ let pair = Immediate::ScalarPair(val, Scalar::from_bool(overflowed));
  self.write_immediate(pair, dest)?;
  } else {
  assert!(self.tcx.sess.opts.unstable_opts.randomize_layout);

compiler/rustc_const_eval/src/interpret/place.rs

@@ -141,7 +141,7 @@ impl<Prov: Provenance> MemPlace<Prov> {
  match self.meta {
  MemPlaceMeta::None => Immediate::from(Scalar::from_maybe_pointer(self.ptr, cx)),
  MemPlaceMeta::Meta(meta) => {
- Immediate::ScalarPair(Scalar::from_maybe_pointer(self.ptr, cx).into(), meta.into())
+ Immediate::ScalarPair(Scalar::from_maybe_pointer(self.ptr, cx), meta)
  }
  }
  }

compiler/rustc_infer/src/infer/mod.rs

@@ -1920,7 +1920,7 @@ impl<'tcx> TypeTrace<'tcx> {
  ) -> TypeTrace<'tcx> {
  TypeTrace {
  cause: cause.clone(),
- values: PolyTraitRefs(ExpectedFound::new(a_is_expected, a.into(), b.into())),
+ values: PolyTraitRefs(ExpectedFound::new(a_is_expected, a, b)),
  }
  }
 

compiler/rustc_middle/src/ty/vtable.rs

@@ -88,8 +88,8 @@ pub(super) fn vtable_allocation_provider<'tcx>(
  let fn_ptr = Pointer::from(fn_alloc_id);
  Scalar::from_pointer(fn_ptr, &tcx)
  }
- VtblEntry::MetadataSize => Scalar::from_uint(size, ptr_size).into(),
- VtblEntry::MetadataAlign => Scalar::from_uint(align, ptr_size).into(),
+ VtblEntry::MetadataSize => Scalar::from_uint(size, ptr_size),
+ VtblEntry::MetadataAlign => Scalar::from_uint(align, ptr_size),
  VtblEntry::Vacant => continue,
  VtblEntry::Method(instance) => {
  // Prepare the fn ptr we write into the vtable.

compiler/rustc_mir_build/src/build/expr/as_place.rs

@@ -356,7 +356,7 @@ impl<'tcx> PlaceBuilder<'tcx> {
  match self {
  PlaceBuilder::Local { local, projection } => PlaceBuilder::Local {
  local: *local,
- projection: Vec::from_iter(projection.iter().copied().chain([elem.into()])),
+ projection: Vec::from_iter(projection.iter().copied().chain([elem])),
  },
  PlaceBuilder::Upvar { upvar, projection } => PlaceBuilder::Upvar {
  upvar: *upvar,

compiler/rustc_mir_transform/src/const_prop.rs

@@ -701,8 +701,8 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
  BinOp::Mul if const_arg.layout.ty.is_integral() && arg_value == 0 => {
  if let Rvalue::CheckedBinaryOp(_, _) = rvalue {
  let val = Immediate::ScalarPair(
- const_arg.to_scalar().into(),
- Scalar::from_bool(false).into(),
+ const_arg.to_scalar(),
+ Scalar::from_bool(false),
  );
  this.ecx.write_immediate(val, &dest)
  } else {

compiler/rustc_parse/src/parser/mod.rs

@@ -25,7 +25,7 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
 use rustc_ast::AttrId;
 use rustc_ast::DUMMY_NODE_ID;
-use rustc_ast::{self as ast, AnonConst, AttrStyle, AttrVec, Const, DelimArgs, Extern};
+use rustc_ast::{self as ast, AnonConst, AttrStyle, Const, DelimArgs, Extern};
 use rustc_ast::{Async, AttrArgs, AttrArgsEq, Expr, ExprKind, MacDelimiter, Mutability, StrLit};
 use rustc_ast::{HasAttrs, HasTokens, Unsafe, Visibility, VisibilityKind};
 use rustc_ast_pretty::pprust;
@@ -1217,11 +1217,7 @@ impl<'a> Parser<'a> {
  value: self.mk_expr(blk.span, ExprKind::Block(blk, None)),
  };
  let blk_span = anon_const.value.span;
- Ok(self.mk_expr_with_attrs(
- span.to(blk_span),
- ExprKind::ConstBlock(anon_const),
- AttrVec::from(attrs),
- ))
+ Ok(self.mk_expr_with_attrs(span.to(blk_span), ExprKind::ConstBlock(anon_const), attrs))
  }
 
  /// Parses mutability (`mut` or nothing).

compiler/rustc_passes/src/lang_items.rs

@@ -83,7 +83,6 @@ impl<'tcx> LanguageItemCollector<'tcx> {
  .map(|p| p.display().to_string())
  .collect::<Vec<_>>()
  .join(", ")
- .into()
  };
  let first_defined_span = self.tcx.hir().span_if_local(original_def_id);
  let mut orig_crate_name = Empty;
@@ -98,7 +97,6 @@ impl<'tcx> LanguageItemCollector<'tcx> {
  .map(|p| p.display().to_string())
  .collect::<Vec<_>>()
  .join(", ")
- .into()
  };
  if first_defined_span.is_none() {
  orig_crate_name = self.tcx.crate_name(original_def_id.krate);

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -1735,8 +1735,8 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  values.map(|(_, is_normalized_ty_expected, normalized_ty, expected_ty)| {
  infer::ValuePairs::Terms(ExpectedFound::new(
  is_normalized_ty_expected,
- normalized_ty.into(),
- expected_ty.into(),
+ normalized_ty,
+ expected_ty,
  ))
  }),
  err,