Auto merge of #22963 - Manishearth:rollup, r=Manishearth

src/doc/intro.md

@@ -510,10 +510,10 @@ numbers[1] is 3
 numbers[0] is 2
 ```
 
-Each time, we can get a slithtly different output because the threads
-are not quaranteed to run in any set order. If you get the same order
-every time it is because each of these threads are very small and
-complete too fast for their indeterminate behavior to surface.
+Each time, we can get a slightly different output because the threads are not
+guaranteed to run in any set order. If you get the same order every time it is
+because each of these threads are very small and complete too fast for their
+indeterminate behavior to surface.
 
 The important part here is that the Rust compiler was able to use ownership to
 give us assurance _at compile time_ that we weren't doing something incorrect

src/doc/trpl/guessing-game.md

@@ -422,11 +422,11 @@ In this case, we say `x` is a `u32` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = "5".parse::<u32>(); // input_num: Option<u32>
-let input_num: Result<u32, _> = "5".parse(); // input_num: Result<u32, <u32 as FromStr>::Err>
+let input_num_option = "5".parse::<u32>().ok(); // input_num: Option<u32>
+let input_num_result: Result<u32, _> = "5".parse(); // input_num: Result<u32, <u32 as FromStr>::Err>
 ```
 
-Here we're converting the `Result` returned by `parse` to an `Option` by using
+Above, we're converting the `Result` returned by `parse` to an `Option` by using
 the `ok` method as well. Anyway, with us now converting our input to a number,
 our code looks like this:
 
@@ -470,14 +470,14 @@ Let's try it out!
 ```bash
 $ cargo build
  Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
-src/main.rs:22:15: 22:24 error: mismatched types: expected `u32` but found `core::option::Option<u32>` (expected u32 but found enum core::option::Option)
-src/main.rs:22 match cmp(input_num, secret_number) {
+src/main.rs:21:15: 21:24 error: mismatched types: expected `u32`, found `core::result::Result<u32, core::num::ParseIntError>` (expected u32, found enum `core::result::Result`) [E0308]
+src/main.rs:21 match cmp(input_num, secret_number) {
  ^~~~~~~~~
 error: aborting due to previous error
 ```
 
-Oh yeah! Our `input_num` has the type `Option<u32>`, rather than `u32`. We
-need to unwrap the Option. If you remember from before, `match` is a great way
+Oh yeah! Our `input_num` has the type `Result<u32, <some error>>`, rather than `u32`. We
+need to unwrap the Result. If you remember from before, `match` is a great way
 to do that. Try this code:
 
 ```{rust,no_run}
@@ -500,7 +500,7 @@ fn main() {
  let input_num: Result<u32, _> = input.parse();
 
  let num = match input_num {
- Ok(num) => num,
+ Ok(n) => n,
  Err(_) => {
  println!("Please input a number!");
  return;
@@ -524,7 +524,7 @@ fn cmp(a: u32, b: u32) -> Ordering {
 }
 ```
 
-We use a `match` to either give us the `u32` inside of the `Option`, or else
+We use a `match` to either give us the `u32` inside of the `Result`, or else
 print an error message and return. Let's give this a shot:
 
 ```bash

src/libcollections/fmt.rs

@@ -364,7 +364,7 @@
 //! * `o` - precedes the argument with a "0o"
 //! * '0' - This is used to indicate for integer formats that the padding should
 //! both be done with a `0` character as well as be sign-aware. A format
-//! like `{:08d}` would yield `00000001` for the integer `1`, while the
+//! like `{:08}` would yield `00000001` for the integer `1`, while the
 //! same format would yield `-0000001` for the integer `-1`. Notice that
 //! the negative version has one fewer zero than the positive version.
 //!

src/librustc/metadata/tydecode.rs

@@ -555,11 +555,9 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
  'k' => {
  assert_eq!(next(st), '[');
  let did = parse_def_(st, ClosureSource, conv);
- let region = parse_region_(st, conv);
  let substs = parse_substs_(st, conv);
  assert_eq!(next(st), ']');
- return ty::mk_closure(st.tcx, did,
- st.tcx.mk_region(region), st.tcx.mk_substs(substs));
+ return ty::mk_closure(st.tcx, did, st.tcx.mk_substs(substs));
  }
  'P' => {
  assert_eq!(next(st), '[');

src/librustc/metadata/tyencode.rs

@@ -139,9 +139,8 @@ pub fn enc_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>, t: Ty<'t
  enc_substs(w, cx, substs);
  mywrite!(w, "]");
  }
- ty::ty_closure(def, region, substs) => {
+ ty::ty_closure(def, substs) => {
  mywrite!(w, "k[{}|", (cx.ds)(def));
- enc_region(w, cx, *region);
  enc_substs(w, cx, substs);
  mywrite!(w, "]");
  }

src/librustc/middle/fast_reject.rs

@@ -74,7 +74,7 @@ pub fn simplify_type(tcx: &ty::ctxt,
  let def_id = tcx.lang_items.owned_box().unwrap();
  Some(StructSimplifiedType(def_id))
  }
- ty::ty_closure(def_id, _, _) => {
+ ty::ty_closure(def_id, _) => {
  Some(ClosureSimplifiedType(def_id))
  }
  ty::ty_tup(ref tys) => {

src/librustc/middle/infer/combine.rs

@@ -503,15 +503,14 @@ pub fn super_tys<'tcx, C>(this: &C,
  Ok(ty::mk_struct(tcx, a_id, tcx.mk_substs(substs)))
  }
 
- (&ty::ty_closure(a_id, a_region, a_substs),
- &ty::ty_closure(b_id, b_region, b_substs))
+ (&ty::ty_closure(a_id, a_substs),
+ &ty::ty_closure(b_id, b_substs))
  if a_id == b_id => {
  // All ty_closure types with the same id represent
  // the (anonymous) type of the same closure expression. So
  // all of their regions should be equated.
- let region = try!(this.equate().regions(*a_region, *b_region));
  let substs = try!(this.substs_variances(None, a_substs, b_substs));
- Ok(ty::mk_closure(tcx, a_id, tcx.mk_region(region), tcx.mk_substs(substs)))
+ Ok(ty::mk_closure(tcx, a_id, tcx.mk_substs(substs)))
  }
 
  (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => {

src/librustc/middle/liveness.rs

@@ -1496,7 +1496,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
  fn fn_ret(&self, id: NodeId) -> ty::PolyFnOutput<'tcx> {
  let fn_ty = ty::node_id_to_type(self.ir.tcx, id);
  match fn_ty.sty {
- ty::ty_closure(closure_def_id, _, substs) =>
+ ty::ty_closure(closure_def_id, substs) =>
  self.ir.tcx.closure_type(closure_def_id, substs).sig.output(),
  _ =>
  ty::ty_fn_ret(fn_ty),

src/librustc/middle/mem_categorization.rs

@@ -607,7 +607,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
  def::DefUpvar(var_id, fn_node_id) => {
  let ty = try!(self.node_ty(fn_node_id));
  match ty.sty {
- ty::ty_closure(closure_id, _, _) => {
+ ty::ty_closure(closure_id, _) => {
  match self.typer.closure_kind(closure_id) {
  Some(kind) => {
  self.cat_upvar(id, span, var_id, fn_node_id, kind)

src/librustc/middle/region.rs

@@ -320,8 +320,10 @@ impl InnermostEnclosingExpr {
 
 #[derive(Debug, Copy)]
 pub struct Context {
+ /// the scope that contains any new variables declared
  var_parent: InnermostDeclaringBlock,
 
+ /// region parent of expressions etc
  parent: InnermostEnclosingExpr,
 }
 

src/librustc/middle/traits/project.rs

@@ -154,7 +154,7 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext
  debug!("consider_unification_despite_ambiguity: self_ty.sty={:?}",
  self_ty.sty);
  match self_ty.sty {
- ty::ty_closure(closure_def_id, _, substs) => {
+ ty::ty_closure(closure_def_id, substs) => {
  let closure_typer = selcx.closure_typer();
  let closure_type = closure_typer.closure_type(closure_def_id, substs);
  let ty::Binder((_, ret_type)) =

src/librustc/middle/traits/select.rs

@@ -293,7 +293,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  // lifetimes can appear inside the self-type.
  let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
  let (closure_def_id, substs) = match self_ty.sty {
- ty::ty_closure(id, _, ref substs) => (id, substs.clone()),
+ ty::ty_closure(id, ref substs) => (id, substs.clone()),
  _ => { return; }
  };
  assert!(!substs.has_escaping_regions());
@@ -1054,7 +1054,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
  let self_ty = self.infcx.shallow_resolve(obligation.self_ty());
  let (closure_def_id, substs) = match self_ty.sty {
- ty::ty_closure(id, _, ref substs) => (id, substs.clone()),
+ ty::ty_closure(id, ref substs) => (id, substs.clone()),
  ty::ty_infer(ty::TyVar(_)) => {
  debug!("assemble_unboxed_closure_candidates: ambiguous self-type");
  candidates.ambiguous = true;
@@ -1533,7 +1533,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
  ty::ty_tup(ref tys) => Ok(If(tys.clone())),
 
- ty::ty_closure(def_id, _, substs) => {
+ ty::ty_closure(def_id, substs) => {
  // FIXME -- This case is tricky. In the case of by-ref
  // closures particularly, we need the results of
  // inference to decide how to reflect the type of each
@@ -1687,7 +1687,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  Some(tys.clone())
  }
 
- ty::ty_closure(def_id, _, substs) => {
+ ty::ty_closure(def_id, substs) => {
  assert_eq!(def_id.krate, ast::LOCAL_CRATE);
 
  match self.closure_typer.closure_upvars(def_id, substs) {

src/librustc/middle/ty.rs

@@ -1367,7 +1367,7 @@ pub enum sty<'tcx> {
  ty_trait(Box<TyTrait<'tcx>>),
  ty_struct(DefId, &'tcx Substs<'tcx>),
 
- ty_closure(DefId, &'tcx Region, &'tcx Substs<'tcx>),
+ ty_closure(DefId, &'tcx Substs<'tcx>),
 
  ty_tup(Vec<Ty<'tcx>>),
 
@@ -2658,8 +2658,7 @@ impl FlagComputation {
  }
  }
 
- &ty_closure(_, region, substs) => {
- self.add_region(*region);
+ &ty_closure(_, substs) => {
  self.add_substs(substs);
  }
 
@@ -2927,10 +2926,9 @@ pub fn mk_struct<'tcx>(cx: &ctxt<'tcx>, struct_id: ast::DefId,
  mk_t(cx, ty_struct(struct_id, substs))
 }
 
-pub fn mk_closure<'tcx>(cx: &ctxt<'tcx>, closure_id: ast::DefId,
- region: &'tcx Region, substs: &'tcx Substs<'tcx>)
+pub fn mk_closure<'tcx>(cx: &ctxt<'tcx>, closure_id: ast::DefId, substs: &'tcx Substs<'tcx>)
  -> Ty<'tcx> {
- mk_t(cx, ty_closure(closure_id, region, substs))
+ mk_t(cx, ty_closure(closure_id, substs))
 }
 
 pub fn mk_var<'tcx>(cx: &ctxt<'tcx>, v: TyVid) -> Ty<'tcx> {
@@ -3513,13 +3511,11 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
  apply_lang_items(cx, did, res)
  }
 
- ty_closure(did, r, substs) => {
+ ty_closure(did, substs) => {
  // FIXME(#14449): `borrowed_contents` below assumes `&mut` closure.
  let param_env = ty::empty_parameter_environment(cx);
  let upvars = closure_upvars(&param_env, did, substs).unwrap();
- TypeContents::union(&upvars,
- |f| tc_ty(cx, &f.ty, cache))
- | borrowed_contents(*r, MutMutable)
+ TypeContents::union(&upvars, |f| tc_ty(cx, &f.ty, cache))
  }
 
  ty_tup(ref tys) => {
@@ -5175,7 +5171,7 @@ pub fn ty_to_def_id(ty: Ty) -> Option<ast::DefId> {
  Some(tt.principal_def_id()),
  ty_struct(id, _) |
  ty_enum(id, _) |
- ty_closure(id, _, _) =>
+ ty_closure(id, _) =>
  Some(id),
  _ =>
  None
@@ -6301,10 +6297,9 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -
  }
  ty_infer(_) => unreachable!(),
  ty_err => byte!(21),
- ty_closure(d, r, _) => {
+ ty_closure(d, _) => {
  byte!(22);
  did(state, d);
- region(state, *r);
  }
  ty_projection(ref data) => {
  byte!(23);
@@ -6618,8 +6613,7 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec<ty::Region>,
  ty_struct(_, substs) => {
  accum_substs(accumulator, substs);
  }
- ty_closure(_, region, substs) => {
- accumulator.push(*region);
+ ty_closure(_, substs) => {
  accum_substs(accumulator, substs);
  }
  ty_bool |

src/librustc/middle/ty_fold.rs

@@ -650,10 +650,9 @@ pub fn super_fold_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
  let substs = substs.fold_with(this);
  ty::ty_struct(did, this.tcx().mk_substs(substs))
  }
- ty::ty_closure(did, ref region, ref substs) => {
- let r = region.fold_with(this);
+ ty::ty_closure(did, ref substs) => {
  let s = substs.fold_with(this);
- ty::ty_closure(did, this.tcx().mk_region(r), this.tcx().mk_substs(s))
+ ty::ty_closure(did, this.tcx().mk_substs(s))
  }
  ty::ty_projection(ref data) => {
  ty::ty_projection(data.fold_with(this))

src/librustc/middle/ty_walk.rs

@@ -45,7 +45,7 @@ impl<'tcx> TypeWalker<'tcx> {
  }
  ty::ty_enum(_, ref substs) |
  ty::ty_struct(_, ref substs) |
- ty::ty_closure(_, _, ref substs) => {
+ ty::ty_closure(_, ref substs) => {
  self.push_reversed(substs.types.as_slice());
  }
  ty::ty_tup(ref ts) => {

src/librustc/util/ppaux.rs

@@ -406,7 +406,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
  data.item_name.user_string(cx))
  }
  ty_str => "str".to_string(),
- ty_closure(ref did, _, substs) => {
+ ty_closure(ref did, substs) => {
  let closure_tys = cx.closure_tys.borrow();
  closure_tys.get(did).map(|closure_type| {
  closure_to_string(cx, &closure_type.subst(cx, substs))

src/librustc_trans/trans/adt.rs

@@ -169,7 +169,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
  Univariant(mk_struct(cx, &ftys[..], packed, t), dtor)
  }
- ty::ty_closure(def_id, _, substs) => {
+ ty::ty_closure(def_id, substs) => {
  let typer = NormalizingClosureTyper::new(cx.tcx());
  let upvars = typer.closure_upvars(def_id, substs).unwrap();
  let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();

src/librustc_trans/trans/base.rs

@@ -291,7 +291,7 @@ pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
  ty::ty_bare_fn(_, ref f) => {
  (&f.sig, f.abi, None)
  }
- ty::ty_closure(closure_did, _, substs) => {
+ ty::ty_closure(closure_did, substs) => {
  let typer = common::NormalizingClosureTyper::new(ccx.tcx());
  function_type = typer.closure_type(closure_did, substs);
  let self_type = self_type_for_closure(ccx, closure_did, fn_ty);
@@ -685,7 +685,7 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
  }
  })
  }
- ty::ty_closure(def_id, _, substs) => {
+ ty::ty_closure(def_id, substs) => {
  let repr = adt::represent_type(cx.ccx(), t);
  let typer = common::NormalizingClosureTyper::new(cx.tcx());
  let upvars = typer.closure_upvars(def_id, substs).unwrap();
@@ -2437,7 +2437,7 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<
  let function_type;
  let (fn_sig, abi, env_ty) = match fn_ty.sty {
  ty::ty_bare_fn(_, ref f) => (&f.sig, f.abi, None),
- ty::ty_closure(closure_did, _, substs) => {
+ ty::ty_closure(closure_did, substs) => {
  let typer = common::NormalizingClosureTyper::new(ccx.tcx());
  function_type = typer.closure_type(closure_did, substs);
  let self_type = self_type_for_closure(ccx, closure_did, fn_ty);
@@ -2454,7 +2454,7 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<
  // These have an odd calling convention, so we need to manually
  // unpack the input ty's
  let input_tys = match fn_ty.sty {
- ty::ty_closure(_, _, _) => {
+ ty::ty_closure(..) => {
  assert!(abi == RustCall);
 
  match fn_sig.inputs[0].sty {

src/librustc_trans/trans/closure.rs

@@ -138,7 +138,7 @@ pub fn get_or_create_declaration_if_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tc
  // duplicate declarations
  let function_type = erase_regions(ccx.tcx(), &function_type);
  let params = match function_type.sty {
- ty::ty_closure(_, _, substs) => &substs.types,
+ ty::ty_closure(_, substs) => &substs.types,
  _ => unreachable!()
  };
  let mono_id = MonoId {

src/librustc_trans/trans/debuginfo.rs

@@ -472,7 +472,7 @@ impl<'tcx> TypeMap<'tcx> {
  }
  }
  },
- ty::ty_closure(def_id, _, substs) => {
+ ty::ty_closure(def_id, substs) => {
  let typer = NormalizingClosureTyper::new(cx.tcx());
  let closure_ty = typer.closure_type(def_id, substs);
  self.get_unique_type_id_of_closure_type(cx,
@@ -2983,7 +2983,7 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
  ty::ty_bare_fn(_, ref barefnty) => {
  subroutine_type_metadata(cx, unique_type_id, &barefnty.sig, usage_site_span)
  }
- ty::ty_closure(def_id, _, substs) => {
+ ty::ty_closure(def_id, substs) => {
  let typer = NormalizingClosureTyper::new(cx.tcx());
  let sig = typer.closure_type(def_id, substs).sig;
  subroutine_type_metadata(cx, unique_type_id, &sig, usage_site_span)

src/librustc_trans/trans/glue.rs

@@ -313,8 +313,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
  ty::mk_nil(bcx.tcx()));
  let (_, variant_cx) = invoke(variant_cx, dtor_addr, &args[..], dtor_ty, DebugLoc::None);
 
- variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope);
- variant_cx
+ variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope)
  })
 }