Cleanup formatting

Author: Aaron1011

src/librustc/traits/select.rs

@@ -429,7 +429,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
  intercrate: None,
  inferred_obligations: SnapshotVec::new(),
  intercrate_ambiguity_causes: None,
- allow_negative_impls: false
+ allow_negative_impls: false,
  }
  }
 
@@ -442,7 +442,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
  intercrate: Some(mode),
  inferred_obligations: SnapshotVec::new(),
  intercrate_ambiguity_causes: None,
- allow_negative_impls: false
+ allow_negative_impls: false,
  }
  }
 
@@ -455,7 +455,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
  intercrate: None,
  inferred_obligations: SnapshotVec::new(),
  intercrate_ambiguity_causes: None,
- allow_negative_impls
+ allow_negative_impls,
  }
  }
 

src/librustdoc/clean/auto_trait.rs

@@ -315,7 +315,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
 
  // Due to the way projections are handled by SelectionContext, we need to run
  // evaluate_predicates twice: once on the original param env, and once on the result of
- // the first evaluate_predicates call
+ // the first evaluate_predicates call.
  //
  // The problem is this: most of rustc, including SelectionContext and traits::project,
  // are designed to work with a concrete usage of a type (e.g. Vec<u8>
@@ -338,7 +338,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  // We fix the first assumption by manually clearing out all of the InferCtxt's caches
  // in between calls to SelectionContext.select. This allows us to keep all of the
  // intermediate types we create bound to the 'tcx lifetime, rather than needing to lift
- // them between calls
+ // them between calls.
  //
  // We fix the second assumption by reprocessing the result of our first call to
  // evaluate_predicates. Using the example of '<T as SomeTrait>::SomeItem = K', our first
@@ -457,13 +457,8 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  infcx.freshen(p)
  }
 
- fn evaluate_nested_obligations<
- 'b,
- 'c,
- 'd,
- 'cx,
- T: Iterator<Item = Obligation<'cx, ty::Predicate<'cx>>>,
- >(
+ fn evaluate_nested_obligations<'b, 'c, 'd, 'cx,
+ T: Iterator<Item = Obligation<'cx, ty::Predicate<'cx>>>>(
  &self,
  ty: ty::Ty,
  nested: T,
@@ -732,8 +727,8 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  }
  }
 
- // This is very simiiar to handle_lifetimes. Instead of matching ty::Region's to ty::Region's,
- // however, we match ty::RegionVid's to ty::Region's
+ // This is very similar to handle_lifetimes. However, instead of matching ty::Region's
+ // to each other, we match ty::RegionVid's to ty::Region's
  fn map_vid_to_region<'cx>(
  &self,
  regions: &RegionConstraintData<'cx>,
@@ -843,7 +838,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  // with determining if a given set up constraints/predicates *are* met, given some
  // starting conditions (e.g. user-provided code). For this reason, it's easier
  // to perform the calculations we need on our own, rather than trying to make
- // existing inference/solver code do what we want
+ // existing inference/solver code do what we want.
  fn handle_lifetimes<'cx>(
  &self,
  regions: &RegionConstraintData<'cx>,
@@ -852,8 +847,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  // Our goal is to 'flatten' the list of constraints by eliminating
  // all intermediate RegionVids. At the end, all constraints should
  // be between Regions (aka region variables). This gives us the information
- // we need to create the Generics
- //
+ // we need to create the Generics.
  let mut finished = FxHashMap();
 
  let mut vid_map: FxHashMap<RegionTarget, RegionDeps> = FxHashMap();
@@ -1021,7 +1015,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  ty_to_fn: FxHashMap<Type, (Option<PolyTrait>, Option<Type>)>,
  lifetime_to_bounds: FxHashMap<Lifetime, FxHashSet<Lifetime>>,
  ) -> Vec<WherePredicate> {
- let final_predicates = ty_to_bounds
+ ty_to_bounds
  .into_iter()
  .flat_map(|(ty, mut bounds)| {
  if let Some(data) = ty_to_fn.get(&ty) {
@@ -1096,9 +1090,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  bounds: bounds.into_iter().collect(),
  }),
  )
- .collect();
-
- final_predicates
+ .collect()
  }
 
  // Converts the calculated ParamEnv and lifetime information to a clean::Generics, suitable for
@@ -1380,7 +1372,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
  }
 
  // This is an ugly hack, but it's the simplest way to handle synthetic impls without greatly
- // refactorying either librustdoc or librustc. In particular, allowing new DefIds to be
+ // refactoring either librustdoc or librustc. In particular, allowing new DefIds to be
  // registered after the AST is constructed would require storing the defid mapping in a
  // RefCell, decreasing the performance for normal compilation for very little gain.
  //

src/librustdoc/clean/inline.rs

@@ -120,7 +120,6 @@ pub fn load_attrs(cx: &DocContext, did: DefId) -> clean::Attributes {
  cx.tcx.get_attrs(did).clean(cx)
 }
 
-
 /// Record an external fully qualified name in the external_paths cache.
 ///
 /// These names are used later on by HTML rendering to generate things like
@@ -267,7 +266,6 @@ pub fn build_impls(cx: &DocContext, did: DefId, auto_traits: bool) -> Vec<clean:
 
  cx.populated_all_crate_impls.set(true);
 
-
  for &cnum in tcx.crates().iter() {
  for did in tcx.all_trait_implementations(cnum).iter() {
  build_impl(cx, *did, &mut impls);
@@ -373,7 +371,7 @@ pub fn build_impl(cx: &DocContext, did: DefId, ret: &mut Vec<clean::Item>) {
  for_,
  items: trait_items,
  polarity: Some(polarity.clean(cx)),
- synthetic: false
+ synthetic: false,
  }),
  source: tcx.def_span(did).clean(cx),
  name: None,

src/librustdoc/clean/mod.rs

@@ -3077,7 +3077,7 @@ impl Path {
  params: PathParameters::AngleBracketed {
  lifetimes: Vec::new(),
  types: Vec::new(),
- bindings: Vec::new()
+ bindings: Vec::new(),
  }
  }]
  }
@@ -3152,23 +3152,23 @@ fn strip_type(ty: Type) -> Type {
  match ty {
  Type::ResolvedPath { path, typarams, did, is_generic } => {
  Type::ResolvedPath { path: strip_path(&path), typarams, did, is_generic }
- },
+ }
  Type::Tuple(inner_tys) => {
  Type::Tuple(inner_tys.iter().map(|t| strip_type(t.clone())).collect())
- },
+ }
  Type::Slice(inner_ty) => Type::Slice(Box::new(strip_type(*inner_ty))),
  Type::Array(inner_ty, s) => Type::Array(Box::new(strip_type(*inner_ty)), s),
  Type::Unique(inner_ty) => Type::Unique(Box::new(strip_type(*inner_ty))),
  Type::RawPointer(m, inner_ty) => Type::RawPointer(m, Box::new(strip_type(*inner_ty))),
  Type::BorrowedRef { lifetime, mutability, type_ } => {
  Type::BorrowedRef { lifetime, mutability, type_: Box::new(strip_type(*type_)) }
- },
+ }
  Type::QPath { name, self_type, trait_ } => {
  Type::QPath {
  name,
  self_type: Box::new(strip_type(*self_type)), trait_: Box::new(strip_type(*trait_))
  }
- },
+ }
  _ => ty
  }
 }
@@ -3180,15 +3180,15 @@ fn strip_path(path: &Path) -> Path {
  params: PathParameters::AngleBracketed {
  lifetimes: Vec::new(),
  types: Vec::new(),
- bindings: Vec::new()
+ bindings: Vec::new(),
  }
  }
  }).collect();
 
  Path {
  global: path.global,
  def: path.def.clone(),
- segments
+ segments,
  }
 }
 
@@ -3361,7 +3361,6 @@ pub fn get_auto_traits_with_node_id(cx: &DocContext, id: ast::NodeId, name: Stri
 }
 
 pub fn get_auto_traits_with_def_id(cx: &DocContext, id: DefId) -> Vec<Item> {
-
  let finder = AutoTraitFinder {
  cx,
  };
@@ -3404,7 +3403,7 @@ impl Clean<Vec<Item>> for doctree::Impl {
  for_: self.for_.clean(cx),
  items,
  polarity: Some(self.polarity.clean(cx)),
- synthetic: false
+ synthetic: false,
  })
  });
  ret
@@ -3819,8 +3818,6 @@ impl Clean<TypeBinding> for hir::TypeBinding {
  }
 }
 
-
-
 pub fn def_id_to_path(cx: &DocContext, did: DefId, name: Option<String>) -> Vec<String> {
  let crate_name = name.unwrap_or_else(|| cx.tcx.crate_name(did.krate).to_string());
  let relative = cx.tcx.def_path(did).data.into_iter().filter_map(|elem| {
@@ -3835,15 +3832,14 @@ pub fn def_id_to_path(cx: &DocContext, did: DefId, name: Option<String>) -> Vec<
  once(crate_name).chain(relative).collect()
 }
 
-
 // Start of code copied from rust-clippy
 
 pub fn get_trait_def_id(tcx: &TyCtxt, path: &[&str], use_local: bool) -> Option<DefId> {
- return if use_local {
+ if use_local {
  path_to_def_local(tcx, path)
  } else {
  path_to_def(tcx, path)
- };
+ }
 }
 
 pub fn path_to_def_local(tcx: &TyCtxt, path: &[&str]) -> Option<DefId> {
@@ -3878,7 +3874,6 @@ pub fn path_to_def_local(tcx: &TyCtxt, path: &[&str]) -> Option<DefId> {
 pub fn path_to_def(tcx: &TyCtxt, path: &[&str]) -> Option<DefId> {
  let crates = tcx.crates();
 
-
  let krate = crates
  .iter()
  .find(|&&krate| tcx.crate_name(krate) == path[0]);
@@ -3902,7 +3897,7 @@ pub fn path_to_def(tcx: &TyCtxt, path: &[&str]) -> Option<DefId> {
  if path_it.peek().is_none() {
  return match item.def {
  def::Def::Trait(did) => Some(did),
- _ => None
+ _ => None,
  }
  }
 
@@ -3942,7 +3937,7 @@ fn get_path_for_type(tcx: TyCtxt, def_id: DefId, def_ctor: fn(DefId) -> Def) ->
  segments: hir::HirVec::from_vec(apb.names.iter().map(|s| hir::PathSegment {
  name: ast::Name::intern(&s),
  parameters: None,
- infer_types: false
+ infer_types: false,
  }).collect())
  }
 }
@@ -3970,24 +3965,20 @@ enum SimpleBound {
 
 enum AutoTraitResult {
  ExplicitImpl,
-
  PositiveImpl(Generics),
-
  NegativeImpl,
 }
 
 impl AutoTraitResult {
-
  fn is_auto(&self) -> bool {
  match *self {
  AutoTraitResult::PositiveImpl(_) | AutoTraitResult::NegativeImpl => true,
- _ => false
+ _ => false,
  }
  }
 }
 
 impl From<TyParamBound> for SimpleBound {
-
  fn from(bound: TyParamBound) -> Self {
  match bound.clone() {
  TyParamBound::RegionBound(l) => SimpleBound::RegionBound(l),
@@ -4001,7 +3992,7 @@ impl From<TyParamBound> for SimpleBound {
  t.generic_params,
  mod_)
  },
- _ => panic!("Unexpected bound {:?}", bound)
+ _ => panic!("Unexpected bound {:?}", bound),
  }
  }
  }

src/librustdoc/core.rs

@@ -239,13 +239,11 @@ pub fn run_core(search_paths: SearchPaths,
  .collect()
  };
 
- let send_trait;
-
- if crate_name == Some("core".to_string()) {
- send_trait = clean::get_trait_def_id(&tcx, &["marker", "Send"], true);
+ let send_trait = if crate_name == Some("core".to_string()) {
+ clean::get_trait_def_id(&tcx, &["marker", "Send"], true)
  } else {
- send_trait = clean::get_trait_def_id(&tcx, &["core", "marker", "Send"], false)
- }
+ clean::get_trait_def_id(&tcx, &["core", "marker", "Send"], false)
+ };
 
  let ctxt = DocContext {
  tcx,
@@ -262,7 +260,7 @@ pub fn run_core(search_paths: SearchPaths,
  send_trait: send_trait,
  fake_def_ids: RefCell::new(FxHashMap()),
  all_fake_def_ids: RefCell::new(FxHashSet()),
- generated_synthetics: RefCell::new(FxHashSet())
+ generated_synthetics: RefCell::new(FxHashSet()),
  };
  debug!("crate: {:?}", tcx.hir.krate());
 

src/librustdoc/html/render.rs

@@ -169,7 +169,6 @@ pub enum ExternalLocation {
  Unknown,
 }
 
-
 /// Metadata about implementations for a type or trait.
 #[derive(Clone)]
 pub struct Impl {
@@ -523,7 +522,6 @@ pub fn run(mut krate: clean::Crate,
  themes,
  };
 
-
  // If user passed in `--playground-url` arg, we fill in crate name here
  if let Some(url) = playground_url {
  markdown::PLAYGROUND.with(|slot| {
@@ -2512,22 +2510,6 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
  }
  write!(w, "</ul>")?;
  }
-
- write!(w, r#"<script type="text/javascript">
- window.inlined_types=new Set();"#)?;
-
- write!(w, r#"<script type="text/javascript" async
- src="{root_path}/implementors/{path}/{ty}.{name}.js">
- </script>"#,
- root_path = vec![".."; cx.current.len()].join("/"),
- path = if it.def_id.is_local() {
- cx.current.join("/")
- } else {
- let (ref path, _) = cache.external_paths[&it.def_id];
- path[..path.len() - 1].join("/")
- },
- ty = it.type_().css_class(),
- name = *it.name.as_ref().unwrap())?;
  } else {
  // even without any implementations to write in, we still want the heading and list, so the
  // implementors javascript file pulled in below has somewhere to write the impls into

src/librustdoc/html/static/main.js

@@ -1569,20 +1569,17 @@
  for (var i = 0; i < libs.length; ++i) {
  if (libs[i] === currentCrate) { continue; }
  var structs = imp[libs[i]];
+
+ struct_loop:
  for (var j = 0; j < structs.length; ++j) {
  var struct = structs[j];
  var list = struct.synthetic ? synthetic_implementors : implementors;
 
- var bail = false;
  for (var k = 0; k < struct.types.length; k++) {
  if (window.inlined_types.has(struct.types[k])) {
- bail = true;
- break;
+ continue struct_loop;
  }
  }
- if (bail) {
- continue;
- }
 
  var code = document.createElement('code');
  code.innerHTML = struct.text;