refactor: use shorthand fields

src/liballoc/string.rs

@@ -502,7 +502,7 @@ impl String {
  #[stable(feature = "rust1", since = "1.0.0")]
  pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error> {
  match str::from_utf8(&vec) {
- Ok(..) => Ok(String { vec: vec }),
+ Ok(..) => Ok(String { vec }),
  Err(e) => {
  Err(FromUtf8Error {
  bytes: vec,

src/libpanic_unwind/dwarf/mod.rs

@@ -29,7 +29,7 @@ struct Unaligned<T>(T);
 
 impl DwarfReader {
  pub fn new(ptr: *const u8) -> DwarfReader {
- DwarfReader { ptr: ptr }
+ DwarfReader { ptr }
  }
 
  // DWARF streams are packed, so e.g. a u32 would not necessarily be aligned

src/libpanic_unwind/seh64_gnu.rs

@@ -41,7 +41,7 @@ struct PanicData {
 }
 
 pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
- let panic_ctx = Box::new(PanicData { data: data });
+ let panic_ctx = Box::new(PanicData { data });
  let params = [Box::into_raw(panic_ctx) as c::ULONG_PTR];
  c::RaiseException(RUST_PANIC,
  c::EXCEPTION_NONCONTINUABLE,

src/librustc/infer/resolve.rs

@@ -26,7 +26,7 @@ pub struct OpportunisticTypeResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 
 impl<'a, 'gcx, 'tcx> OpportunisticTypeResolver<'a, 'gcx, 'tcx> {
  pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self {
- OpportunisticTypeResolver { infcx: infcx }
+ OpportunisticTypeResolver { infcx }
  }
 }
 
@@ -54,7 +54,7 @@ pub struct OpportunisticTypeAndRegionResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 
 impl<'a, 'gcx, 'tcx> OpportunisticTypeAndRegionResolver<'a, 'gcx, 'tcx> {
  pub fn new(infcx: &'a InferCtxt<'a, 'gcx, 'tcx>) -> Self {
- OpportunisticTypeAndRegionResolver { infcx: infcx }
+ OpportunisticTypeAndRegionResolver { infcx }
  }
 }
 

src/librustc/infer/type_variable.rs

@@ -169,7 +169,7 @@ impl<'tcx> TypeVariableTable<'tcx> {
  // Hack: we only need this so that `types_escaping_snapshot`
  // can see what has been unified; see the Delegate impl for
  // more details.
- self.values.record(Instantiate { vid: vid });
+ self.values.record(Instantiate { vid });
  }
 
  /// Creates a new type variable.

src/librustc/infer/unify_key.rs

@@ -43,7 +43,7 @@ impl UnifyValue for RegionVidKey {
  value2.min_vid
  };
 
- Ok(RegionVidKey { min_vid: min_vid })
+ Ok(RegionVidKey { min_vid })
  }
 }
 

src/librustc/middle/stability.rs

@@ -469,7 +469,7 @@ impl<'a, 'tcx> Index<'tcx> {
 /// Cross-references the feature names of unstable APIs with enabled
 /// features and possibly prints errors.
 pub fn check_unstable_api_usage<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- let mut checker = Checker { tcx: tcx };
+ let mut checker = Checker { tcx };
  tcx.hir.krate().visit_all_item_likes(&mut checker.as_deep_visitor());
 }
 

src/librustc/mir/mod.rs

@@ -2871,7 +2871,7 @@ impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> {
  use mir::TerminatorKind::*;
 
  let kind = match self.kind {
- Goto { target } => Goto { target: target },
+ Goto { target } => Goto { target },
  SwitchInt {
  ref discr,
  switch_ty,

src/librustc/mir/tcx.rs

@@ -32,7 +32,7 @@ pub enum PlaceTy<'tcx> {
 
 impl<'a, 'gcx, 'tcx> PlaceTy<'tcx> {
  pub fn from_ty(ty: Ty<'tcx>) -> PlaceTy<'tcx> {
- PlaceTy::Ty { ty: ty }
+ PlaceTy::Ty { ty }
  }
 
  pub fn to_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {

src/librustc/traits/project.rs

@@ -269,7 +269,7 @@ fn project_and_unify_type<'cx, 'gcx, 'tcx>(
  },
  Err(err) => {
  debug!("project_and_unify_type: equating types encountered error {:?}", err);
- Err(MismatchedProjectionTypes { err: err })
+ Err(MismatchedProjectionTypes { err })
  }
  }
 }

src/librustc/traits/select.rs

@@ -3434,7 +3434,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
  _ => bug!(),
  };
 
- Ok(VtableBuiltinData { nested: nested })
+ Ok(VtableBuiltinData { nested })
  }
 
  ///////////////////////////////////////////////////////////////////////////

src/librustc/ty/_match.rs

@@ -34,7 +34,7 @@ pub struct Match<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 
 impl<'a, 'gcx, 'tcx> Match<'a, 'gcx, 'tcx> {
  pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Match<'a, 'gcx, 'tcx> {
- Match { tcx: tcx }
+ Match { tcx }
  }
 }
 

src/librustc/ty/fold.rs

@@ -82,7 +82,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone {
  }
 
  fn has_type_flags(&self, flags: TypeFlags) -> bool {
- self.visit_with(&mut HasTypeFlagsVisitor { flags: flags })
+ self.visit_with(&mut HasTypeFlagsVisitor { flags })
  }
  fn has_projections(&self) -> bool {
  self.has_type_flags(TypeFlags::HAS_PROJECTION)

src/librustc_codegen_llvm/llvm/mod.rs

@@ -190,7 +190,7 @@ impl ObjectFile {
  pub fn new(llmb: &'static mut MemoryBuffer) -> Option<ObjectFile> {
  unsafe {
  let llof = LLVMCreateObjectFile(llmb)?;
- Some(ObjectFile { llof: llof })
+ Some(ObjectFile { llof })
  }
  }
 }

src/librustc_codegen_llvm/mir/analyze.rs

@@ -328,7 +328,7 @@ pub fn cleanup_kinds<'a, 'tcx>(mir: &mir::Mir<'tcx>) -> IndexVec<mir::BasicBlock
  funclet, succ, kind);
  match kind {
  CleanupKind::NotCleanup => {
- result[succ] = CleanupKind::Internal { funclet: funclet };
+ result[succ] = CleanupKind::Internal { funclet };
  }
  CleanupKind::Funclet => {
  if funclet != succ {

src/librustc_codegen_utils/symbol_names_test.rs

@@ -32,7 +32,7 @@ pub fn report_symbol_names<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
  }
 
  tcx.dep_graph.with_ignore(|| {
- let mut visitor = SymbolNamesTest { tcx: tcx };
+ let mut visitor = SymbolNamesTest { tcx };
  tcx.hir.krate().visit_all_item_likes(&mut visitor);
  })
 }

src/librustc_data_structures/flock.rs

@@ -214,7 +214,7 @@ cfg_if! {
  unsafe { libc::close(fd); }
  Err(err)
  } else {
- Ok(Lock { fd: fd })
+ Ok(Lock { fd })
  }
  }
  }

src/librustc_data_structures/svh.rs

@@ -31,7 +31,7 @@ impl Svh {
  /// compute the SVH from some HIR, you want the `calculate_svh`
  /// function found in `librustc_incremental`.
  pub fn new(hash: u64) -> Svh {
- Svh { hash: hash }
+ Svh { hash }
  }
 
  pub fn as_u64(&self) -> u64 {

src/librustc_lint/types.rs

@@ -794,7 +794,7 @@ impl LintPass for ImproperCTypes {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImproperCTypes {
  fn check_foreign_item(&mut self, cx: &LateContext, it: &hir::ForeignItem) {
- let mut vis = ImproperCTypesVisitor { cx: cx };
+ let mut vis = ImproperCTypesVisitor { cx };
  let abi = cx.tcx.hir.get_foreign_abi(it.id);
  if abi != Abi::RustIntrinsic && abi != Abi::PlatformIntrinsic {
  match it.node {

src/librustc_metadata/encoder.rs

@@ -323,7 +323,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
  index.record(DefId::local(CRATE_DEF_INDEX),
  IsolatedEncoder::encode_info_for_mod,
  FromId(CRATE_NODE_ID, (&krate.module, &krate.attrs, &vis)));
- let mut visitor = EncodeVisitor { index: index };
+ let mut visitor = EncodeVisitor { index };
  krate.visit_all_item_likes(&mut visitor.as_deep_visitor());
  for macro_def in &krate.exported_macros {
  visitor.visit_macro_def(macro_def);

src/librustc_mir/build/scope.rs

@@ -453,7 +453,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
  }
  let scope = &self.scopes[len - scope_count];
  self.cfg.terminate(block, scope.source_info(span),
- TerminatorKind::Goto { target: target });
+ TerminatorKind::Goto { target });
  }
 
  /// Creates a path that performs all required cleanup for dropping a generator.
@@ -1019,7 +1019,7 @@ fn build_diverge_scope<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
  } else {
  let block = cfg.start_new_cleanup_block();
  cfg.push_end_region(tcx, block, source_info(span), scope.region_scope);
- cfg.terminate(block, source_info(span), TerminatorKind::Goto { target: target });
+ cfg.terminate(block, source_info(span), TerminatorKind::Goto { target });
  *cached_block = Some(block);
  block
  }

src/librustc_mir/dataflow/impls/borrowed_locals.rs

@@ -28,7 +28,7 @@ pub struct HaveBeenBorrowedLocals<'a, 'tcx: 'a> {
 impl<'a, 'tcx: 'a> HaveBeenBorrowedLocals<'a, 'tcx> {
  pub fn new(mir: &'a Mir<'tcx>)
  -> Self {
- HaveBeenBorrowedLocals { mir: mir }
+ HaveBeenBorrowedLocals { mir }
  }
 
  pub fn mir(&self) -> &Mir<'tcx> {

src/librustc_mir/dataflow/impls/storage_liveness.rs

@@ -21,7 +21,7 @@ pub struct MaybeStorageLive<'a, 'tcx: 'a> {
 impl<'a, 'tcx: 'a> MaybeStorageLive<'a, 'tcx> {
  pub fn new(mir: &'a Mir<'tcx>)
  -> Self {
- MaybeStorageLive { mir: mir }
+ MaybeStorageLive { mir }
  }
 
  pub fn mir(&self) -> &Mir<'tcx> {

src/librustc_mir/hair/pattern/check_match.rs

@@ -52,7 +52,7 @@ impl<'a, 'tcx> Visitor<'tcx> for OuterVisitor<'a, 'tcx> {
 }
 
 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- tcx.hir.krate().visit_all_item_likes(&mut OuterVisitor { tcx: tcx }.as_deep_visitor());
+ tcx.hir.krate().visit_all_item_likes(&mut OuterVisitor { tcx }.as_deep_visitor());
  tcx.sess.abort_if_errors();
 }
 

src/librustc_mir/hair/pattern/mod.rs

@@ -459,7 +459,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
  })
  .collect();
 
- PatternKind::Leaf { subpatterns: subpatterns }
+ PatternKind::Leaf { subpatterns }
  }
  ty::Error => { // Avoid ICE (#50577)
  return Pattern { span: pat.span, ty, kind: Box::new(PatternKind::Wild) };
@@ -666,13 +666,13 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
  subpatterns,
  }
  } else {
- PatternKind::Leaf { subpatterns: subpatterns }
+ PatternKind::Leaf { subpatterns }
  }
  }
 
  Def::Struct(..) | Def::StructCtor(..) | Def::Union(..) |
  Def::TyAlias(..) | Def::AssociatedTy(..) | Def::SelfTy(..) | Def::SelfCtor(..) => {
- PatternKind::Leaf { subpatterns: subpatterns }
+ PatternKind::Leaf { subpatterns }
  }
 
  _ => {

src/librustc_mir/transform/elaborate_drops.rs

@@ -495,7 +495,7 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> {
  let target = self.patch.new_block(BasicBlockData {
  statements: vec![assign],
  terminator: Some(Terminator {
- kind: TerminatorKind::Goto { target: target },
+ kind: TerminatorKind::Goto { target },
  ..*terminator
  }),
  is_cleanup: false,

src/librustc_mir/transform/simplify.rs

@@ -302,7 +302,7 @@ impl MirPass for SimplifyLocals {
 
  let map = make_local_map(&mut mir.local_decls, marker.locals);
  // Update references to all vars and tmps now
- LocalUpdater { map: map }.visit_mir(mir);
+ LocalUpdater { map }.visit_mir(mir);
  mir.local_decls.shrink_to_fit();
  }
 }

src/librustc_mir/transform/simplify_branches.rs

@@ -57,7 +57,7 @@ impl MirPass for SimplifyBranches {
  TerminatorKind::Assert {
  target, cond: Operand::Constant(ref c), expected, ..
  } if (c.literal.assert_bool(tcx) == Some(true)) == expected => {
- TerminatorKind::Goto { target: target }
+ TerminatorKind::Goto { target }
  },
  TerminatorKind::FalseEdges { real_target, .. } => {
  TerminatorKind::Goto { target: real_target }

src/librustc_passes/ast_validation.rs

@@ -691,5 +691,5 @@ pub fn check_crate(session: &Session, krate: &Crate) {
  is_banned: false,
  }, krate);
 
- visit::walk_crate(&mut AstValidator { session: session }, krate)
+ visit::walk_crate(&mut AstValidator { session }, krate)
 }

src/librustc_resolve/lib.rs

@@ -4424,7 +4424,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
  // declared as public (due to pruning, we don't explore
  // outside crate private modules => no need to check this)
  if !in_module_is_extern || name_binding.vis == ty::Visibility::Public {
- candidates.push(ImportSuggestion { path: path });
+ candidates.push(ImportSuggestion { path });
  }
  }
  }
@@ -4533,7 +4533,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
  span: name_binding.span,
  segments: path_segments,
  };
- result = Some((module, ImportSuggestion { path: path }));
+ result = Some((module, ImportSuggestion { path }));
  } else {
  // add the module to the lookup
  if seen_modules.insert(module.def_id().unwrap()) {

src/librustc_save_analysis/json_dumper.rs

@@ -71,7 +71,7 @@ impl<'b> JsonDumper<CallbackOutput<'b>> {
  config: Config,
  ) -> JsonDumper<CallbackOutput<'b>> {
  JsonDumper {
- output: CallbackOutput { callback: callback },
+ output: CallbackOutput { callback },
  config: config.clone(),
  result: Analysis::new(config),
  }

src/librustc_typeck/check/wfcheck.rs

@@ -962,7 +962,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
  AdtField { ty: field_ty, span: field.span }
  })
  .collect();
- AdtVariant { fields: fields }
+ AdtVariant { fields }
  }
 
  fn enum_variants(&self, enum_def: &hir::EnumDef) -> Vec<AdtVariant<'tcx>> {

src/librustc_typeck/coherence/orphan.rs

@@ -17,7 +17,7 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor;
 use rustc::hir;
 
 pub fn check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- let mut orphan = OrphanChecker { tcx: tcx };
+ let mut orphan = OrphanChecker { tcx };
  tcx.hir.krate().visit_all_item_likes(&mut orphan);
 }
 

src/librustc_typeck/coherence/unsafety.rs

@@ -16,7 +16,7 @@ use rustc::hir::itemlikevisit::ItemLikeVisitor;
 use rustc::hir::{self, Unsafety};
 
 pub fn check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- let mut unsafety = UnsafetyChecker { tcx: tcx };
+ let mut unsafety = UnsafetyChecker { tcx };
  tcx.hir.krate().visit_all_item_likes(&mut unsafety);
 }
 

src/librustc_typeck/collect.rs

@@ -62,7 +62,7 @@ use std::iter;
 // Main entry point
 
 pub fn collect_item_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
- let mut visitor = CollectItemTypesVisitor { tcx: tcx };
+ let mut visitor = CollectItemTypesVisitor { tcx };
  tcx.hir
  .krate()
  .visit_all_item_likes(&mut visitor.as_deep_visitor());

src/librustc_typeck/impl_wf_check.rs

@@ -62,7 +62,7 @@ pub fn impl_wf_check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
  // We will tag this as part of the WF check -- logically, it is,
  // but it's one that we must perform earlier than the rest of
  // WfCheck.
- tcx.hir.krate().visit_all_item_likes(&mut ImplWfCheck { tcx: tcx });
+ tcx.hir.krate().visit_all_item_likes(&mut ImplWfCheck { tcx });
 }
 
 struct ImplWfCheck<'a, 'tcx: 'a> {

src/librustdoc/clean/mod.rs

@@ -2959,7 +2959,7 @@ impl<'tcx> Clean<Item> for ty::VariantDef {
  source: cx.tcx.def_span(self.did).clean(cx),
  visibility: Some(Inherited),
  def_id: self.did,
- inner: VariantItem(Variant { kind: kind }),
+ inner: VariantItem(Variant { kind }),
  stability: get_stability(cx, self.did),
  deprecation: get_deprecation(cx, self.did),
  }

src/libstd/collections/hash/map.rs

@@ -2854,7 +2854,7 @@ mod test_map {
  slot.borrow_mut()[k] += 1;
  });
 
- Droppable { k: k }
+ Droppable { k }
  }
  }
 

src/libstd/fs.rs

@@ -877,7 +877,7 @@ impl OpenOptions {
 
  fn _open(&self, path: &Path) -> io::Result<File> {
  let inner = fs_imp::File::open(path, &self.0)?;
- Ok(File { inner: inner })
+ Ok(File { inner })
  }
 }