Remove "unboxed" attribute in code referring to new closures.

Author: eddyb

src/librustc/lint/builtin.rs

@@ -1732,7 +1732,7 @@ impl LintPass for Stability {
  ty::MethodStatic(def_id) => {
  def_id
  }
- ty::MethodStaticUnboxedClosure(def_id) => {
+ ty::MethodStaticClosure(def_id) => {
  def_id
  }
  ty::MethodTypeParam(ty::MethodParam {
@@ -1940,7 +1940,7 @@ impl LintPass for UnconditionalRecursion {
  ty::MethodTraitObject(_) => return false,
 
  // This `did` refers directly to the method definition.
- ty::MethodStatic(did) | ty::MethodStaticUnboxedClosure(did) => did,
+ ty::MethodStatic(did) | ty::MethodStaticClosure(did) => did,
 
  // MethodTypeParam are methods from traits:
 

src/librustc/metadata/common.rs

@@ -139,7 +139,7 @@ pub enum astencode_tag { // Reserves 0x40 -- 0x5f
  tag_table_adjustments = 0x51,
  tag_table_moves_map = 0x52,
  tag_table_capture_map = 0x53,
- tag_table_unboxed_closures = 0x54,
+ tag_table_closures = 0x54,
  tag_table_upvar_borrow_map = 0x55,
  tag_table_capture_modes = 0x56,
  tag_table_object_cast_map = 0x57,
@@ -225,10 +225,10 @@ pub struct LinkMeta {
  pub crate_hash: Svh,
 }
 
-pub const tag_unboxed_closures: uint = 0x95;
-pub const tag_unboxed_closure: uint = 0x96;
-pub const tag_unboxed_closure_type: uint = 0x97;
-pub const tag_unboxed_closure_kind: uint = 0x98;
+pub const tag_closures: uint = 0x95;
+pub const tag_closure: uint = 0x96;
+pub const tag_closure_type: uint = 0x97;
+pub const tag_closure_kind: uint = 0x98;
 
 pub const tag_struct_fields: uint = 0x99;
 pub const tag_struct_field: uint = 0x9a;

src/librustc/metadata/encoder.rs

@@ -618,13 +618,12 @@ fn encode_visibility(rbml_w: &mut Encoder, visibility: ast::Visibility) {
  rbml_w.end_tag();
 }
 
-fn encode_unboxed_closure_kind(rbml_w: &mut Encoder,
- kind: ty::UnboxedClosureKind) {
- rbml_w.start_tag(tag_unboxed_closure_kind);
+fn encode_closure_kind(rbml_w: &mut Encoder, kind: ty::ClosureKind) {
+ rbml_w.start_tag(tag_closure_kind);
  let ch = match kind {
- ty::FnUnboxedClosureKind => 'f',
- ty::FnMutUnboxedClosureKind => 'm',
- ty::FnOnceUnboxedClosureKind => 'o',
+ ty::FnClosureKind => 'f',
+ ty::FnMutClosureKind => 'm',
+ ty::FnOnceClosureKind => 'o',
  };
  rbml_w.wr_str(&ch.to_string()[]);
  rbml_w.end_tag();
@@ -1838,24 +1837,19 @@ fn encode_macro_defs(rbml_w: &mut Encoder,
  rbml_w.end_tag();
 }
 
-fn encode_unboxed_closures<'a>(
- ecx: &'a EncodeContext,
- rbml_w: &'a mut Encoder) {
- rbml_w.start_tag(tag_unboxed_closures);
- for (unboxed_closure_id, unboxed_closure) in ecx.tcx
- .unboxed_closures
- .borrow()
- .iter() {
- if unboxed_closure_id.krate != ast::LOCAL_CRATE {
+fn encode_closures<'a>(ecx: &'a EncodeContext, rbml_w: &'a mut Encoder) {
+ rbml_w.start_tag(tag_closures);
+ for (closure_id, closure) in ecx.tcx.closures.borrow().iter() {
+ if closure_id.krate != ast::LOCAL_CRATE {
  continue
  }
 
- rbml_w.start_tag(tag_unboxed_closure);
- encode_def_id(rbml_w, *unboxed_closure_id);
- rbml_w.start_tag(tag_unboxed_closure_type);
- write_closure_type(ecx, rbml_w, &unboxed_closure.closure_type);
+ rbml_w.start_tag(tag_closure);
+ encode_def_id(rbml_w, *closure_id);
+ rbml_w.start_tag(tag_closure_type);
+ write_closure_type(ecx, rbml_w, &closure.closure_type);
  rbml_w.end_tag();
- encode_unboxed_closure_kind(rbml_w, unboxed_closure.kind);
+ encode_closure_kind(rbml_w, closure.kind);
  rbml_w.end_tag();
  }
  rbml_w.end_tag();
@@ -2069,7 +2063,7 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter,
  native_lib_bytes: u64,
  plugin_registrar_fn_bytes: u64,
  macro_defs_bytes: u64,
- unboxed_closure_bytes: u64,
+ closure_bytes: u64,
  impl_bytes: u64,
  misc_bytes: u64,
  item_bytes: u64,
@@ -2084,7 +2078,7 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter,
  native_lib_bytes: 0,
  plugin_registrar_fn_bytes: 0,
  macro_defs_bytes: 0,
- unboxed_closure_bytes: 0,
+ closure_bytes: 0,
  impl_bytes: 0,
  misc_bytes: 0,
  item_bytes: 0,
@@ -2156,8 +2150,8 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter,
 
  // Encode the types of all unboxed closures in this crate.
  i = rbml_w.writer.tell().unwrap();
- encode_unboxed_closures(&ecx, &mut rbml_w);
- stats.unboxed_closure_bytes = rbml_w.writer.tell().unwrap() - i;
+ encode_closures(&ecx, &mut rbml_w);
+ stats.closure_bytes = rbml_w.writer.tell().unwrap() - i;
 
  // Encode the def IDs of impls, for coherence checking.
  i = rbml_w.writer.tell().unwrap();

src/librustc/metadata/tydecode.rs

@@ -58,7 +58,7 @@ pub enum DefIdSource {
  RegionParameter,
 
  // Identifies an unboxed closure
- UnboxedClosureSource
+ ClosureSource
 }
 
 // type conv_did = impl FnMut(DefIdSource, ast::DefId) -> ast::DefId;
@@ -537,11 +537,11 @@ 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, UnboxedClosureSource, conv);
+ 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_unboxed_closure(st.tcx, did,
+ return ty::mk_closure(st.tcx, did,
  st.tcx.mk_region(region), st.tcx.mk_substs(substs));
  }
  'P' => {

src/librustc/metadata/tyencode.rs

@@ -139,7 +139,7 @@ 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_unboxed_closure(def, region, substs) => {
+ ty::ty_closure(def, region, substs) => {
  mywrite!(w, "k[{}|", (cx.ds)(def));
  enc_region(w, cx, *region);
  enc_substs(w, cx, substs);

src/librustc/middle/astencode.rs

@@ -21,7 +21,7 @@ use metadata::encoder as e;
 use middle::region;
 use metadata::tydecode;
 use metadata::tydecode::{DefIdSource, NominalType, TypeWithId, TypeParameter};
-use metadata::tydecode::{RegionParameter, UnboxedClosureSource};
+use metadata::tydecode::{RegionParameter, ClosureSource};
 use metadata::tyencode;
 use middle::mem_categorization::Typer;
 use middle::subst;
@@ -618,8 +618,8 @@ impl<'tcx> tr for MethodOrigin<'tcx> {
  fn tr(&self, dcx: &DecodeContext) -> MethodOrigin<'tcx> {
  match *self {
  ty::MethodStatic(did) => ty::MethodStatic(did.tr(dcx)),
- ty::MethodStaticUnboxedClosure(did) => {
- ty::MethodStaticUnboxedClosure(did.tr(dcx))
+ ty::MethodStaticClosure(did) => {
+ ty::MethodStaticClosure(did.tr(dcx))
  }
  ty::MethodTypeParam(ref mp) => {
  ty::MethodTypeParam(
@@ -643,24 +643,23 @@ impl<'tcx> tr for MethodOrigin<'tcx> {
  }
 }
 
-pub fn encode_unboxed_closure_kind(ebml_w: &mut Encoder,
- kind: ty::UnboxedClosureKind) {
+pub fn encode_closure_kind(ebml_w: &mut Encoder, kind: ty::ClosureKind) {
  use serialize::Encoder;
 
- ebml_w.emit_enum("UnboxedClosureKind", |ebml_w| {
+ ebml_w.emit_enum("ClosureKind", |ebml_w| {
  match kind {
- ty::FnUnboxedClosureKind => {
- ebml_w.emit_enum_variant("FnUnboxedClosureKind", 0, 3, |_| {
+ ty::FnClosureKind => {
+ ebml_w.emit_enum_variant("FnClosureKind", 0, 3, |_| {
  Ok(())
  })
  }
- ty::FnMutUnboxedClosureKind => {
- ebml_w.emit_enum_variant("FnMutUnboxedClosureKind", 1, 3, |_| {
+ ty::FnMutClosureKind => {
+ ebml_w.emit_enum_variant("FnMutClosureKind", 1, 3, |_| {
  Ok(())
  })
  }
- ty::FnOnceUnboxedClosureKind => {
- ebml_w.emit_enum_variant("FnOnceUnboxedClosureKind",
+ ty::FnOnceClosureKind => {
+ ebml_w.emit_enum_variant("FnOnceClosureKind",
  2,
  3,
  |_| {
@@ -736,7 +735,7 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
  this.read_enum_variant(&["vtable_static",
  "vtable_param",
  "vtable_error",
- "vtable_unboxed_closure"],
+ "vtable_closure"],
  |this, i| {
  Ok(match i {
  0 => {
@@ -763,7 +762,7 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> {
  )
  }
  2 => {
- ty::vtable_unboxed_closure(
+ ty::vtable_closure(
  this.read_enum_variant_arg(0u, |this| {
  Ok(this.read_def_id_nodcx(cdata))
  }).unwrap()
@@ -865,8 +864,8 @@ impl<'a, 'tcx> rbml_writer_helpers<'tcx> for Encoder<'a> {
  })
  }
 
- ty::MethodStaticUnboxedClosure(def_id) => {
- this.emit_enum_variant("MethodStaticUnboxedClosure", 1, 1, |this| {
+ ty::MethodStaticClosure(def_id) => {
+ this.emit_enum_variant("MethodStaticClosure", 1, 1, |this| {
  Ok(this.emit_def_id(def_id))
  })
  }
@@ -1322,15 +1321,12 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
  })
  }
 
- for unboxed_closure in tcx.unboxed_closures
- .borrow()
- .get(&ast_util::local_def(id))
- .iter() {
- rbml_w.tag(c::tag_table_unboxed_closures, |rbml_w| {
+ for closure in tcx.closures.borrow().get(&ast_util::local_def(id)).iter() {
+ rbml_w.tag(c::tag_table_closures, |rbml_w| {
  rbml_w.id(id);
  rbml_w.tag(c::tag_table_val, |rbml_w| {
- rbml_w.emit_closure_type(ecx, &unboxed_closure.closure_type);
- encode_unboxed_closure_kind(rbml_w, unboxed_closure.kind)
+ rbml_w.emit_closure_type(ecx, &closure.closure_type);
+ encode_closure_kind(rbml_w, closure.kind)
  })
  })
  }
@@ -1369,8 +1365,8 @@ trait rbml_decoder_decoder_helpers<'tcx> {
  -> subst::Substs<'tcx>;
  fn read_auto_adjustment<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
  -> ty::AutoAdjustment<'tcx>;
- fn read_unboxed_closure<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
-  -> ty::UnboxedClosure<'tcx>;
+ fn read_closure<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
+ -> ty::Closure<'tcx>;
  fn read_auto_deref_ref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
  -> ty::AutoDerefRef<'tcx>;
  fn read_autoref<'a, 'b>(&mut self, dcx: &DecodeContext<'a, 'b, 'tcx>)
@@ -1436,7 +1432,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
  -> ty::MethodOrigin<'tcx>
  {
  self.read_enum("MethodOrigin", |this| {
- let variants = &["MethodStatic", "MethodStaticUnboxedClosure",
+ let variants = &["MethodStatic", "MethodStaticClosure",
  "MethodTypeParam", "MethodTraitObject"];
  this.read_enum_variant(variants, |this, i| {
  Ok(match i {
@@ -1447,7 +1443,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
 
  1 => {
  let def_id = this.read_def_id(dcx);
- ty::MethodStaticUnboxedClosure(def_id)
+ ty::MethodStaticClosure(def_id)
  }
 
  2 => {
@@ -1797,8 +1793,8 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
  }).unwrap()
  }
 
- fn read_unboxed_closure<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
-  -> ty::UnboxedClosure<'tcx> {
+ fn read_closure<'b, 'c>(&mut self, dcx: &DecodeContext<'b, 'c, 'tcx>)
+ -> ty::Closure<'tcx> {
  let closure_type = self.read_opaque(|this, doc| {
  Ok(tydecode::parse_ty_closure_data(
  doc.data,
@@ -1808,21 +1804,21 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
  |s, a| this.convert_def_id(dcx, s, a)))
  }).unwrap();
  let variants = &[
- "FnUnboxedClosureKind",
- "FnMutUnboxedClosureKind",
- "FnOnceUnboxedClosureKind"
+ "FnClosureKind",
+ "FnMutClosureKind",
+ "FnOnceClosureKind"
  ];
- let kind = self.read_enum("UnboxedClosureKind", |this| {
+ let kind = self.read_enum("ClosureKind", |this| {
  this.read_enum_variant(variants, |_, i| {
  Ok(match i {
- 0 => ty::FnUnboxedClosureKind,
- 1 => ty::FnMutUnboxedClosureKind,
- 2 => ty::FnOnceUnboxedClosureKind,
- _ => panic!("bad enum variant for ty::UnboxedClosureKind"),
+ 0 => ty::FnClosureKind,
+ 1 => ty::FnMutClosureKind,
+ 2 => ty::FnOnceClosureKind,
+ _ => panic!("bad enum variant for ty::ClosureKind"),
  })
  })
  }).unwrap();
- ty::UnboxedClosure {
+ ty::Closure {
  closure_type: closure_type,
  kind: kind,
  }
@@ -1864,7 +1860,7 @@ impl<'a, 'tcx> rbml_decoder_decoder_helpers<'tcx> for reader::Decoder<'a> {
  -> ast::DefId {
  let r = match source {
  NominalType | TypeWithId | RegionParameter => dcx.tr_def_id(did),
- TypeParameter | UnboxedClosureSource => dcx.tr_intern_def_id(did)
+ TypeParameter | ClosureSource => dcx.tr_intern_def_id(did)
  };
  debug!("convert_def_id(source={:?}, did={:?})={:?}", source, did, r);
  return r;
@@ -1959,14 +1955,11 @@ fn decode_side_tables(dcx: &DecodeContext,
  let adj: ty::AutoAdjustment = val_dsr.read_auto_adjustment(dcx);
  dcx.tcx.adjustments.borrow_mut().insert(id, adj);
  }
- c::tag_table_unboxed_closures => {
- let unboxed_closure =
- val_dsr.read_unboxed_closure(dcx);
- dcx.tcx
- .unboxed_closures
- .borrow_mut()
- .insert(ast_util::local_def(id),
- unboxed_closure);
+ c::tag_table_closures => {
+ let closure =
+ val_dsr.read_closure(dcx);
+ dcx.tcx.closures.borrow_mut().insert(ast_util::local_def(id),
+ closure);
  }
  _ => {
  dcx.tcx.sess.bug(

src/librustc/middle/dead.rs

@@ -100,7 +100,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
  None => self.check_def_id(def_id)
  }
  }
- ty::MethodStaticUnboxedClosure(_) => {}
+ ty::MethodStaticClosure(_) => {}
  ty::MethodTypeParam(ty::MethodParam {
  ref trait_ref,
  method_num: index,