Don't call new closures "unboxed" wherever possible.

src/doc/reference.md

@@ -2489,10 +2489,6 @@ The currently implemented features of the reference compiler are:
                        for now until the specification of identifiers is fully
                        fleshed out.
 
-* `once_fns` - Onceness guarantees a closure is only executed once. Defining a
-               closure as `once` is unlikely to be supported going forward. So
-               they are hidden behind this feature until they are to be removed.
-
 * `plugin` - Usage of [compiler plugins][plugin] for custom lints or syntax extensions.
              These depend on compiler internals and are subject to change.
 

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,
@@ -2154,10 +2148,10 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter,
     encode_macro_defs(&mut rbml_w, krate);
     stats.macro_defs_bytes = rbml_w.writer.tell().unwrap() - i;
 
-    // Encode the types of all unboxed closures in this crate.
+    // Encode the types of all 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();
@@ -2199,7 +2193,7 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter,
         println!("          native bytes: {}", stats.native_lib_bytes);
         println!("plugin registrar bytes: {}", stats.plugin_registrar_fn_bytes);
         println!("       macro def bytes: {}", stats.macro_defs_bytes);
-        println!(" unboxed closure bytes: {}", stats.unboxed_closure_bytes);
+        println!("         closure bytes: {}", stats.closure_bytes);
         println!("            impl bytes: {}", stats.impl_bytes);
         println!("            misc bytes: {}", stats.misc_bytes);
         println!("            item bytes: {}", stats.item_bytes);

src/librustc/metadata/tydecode.rs

@@ -57,8 +57,8 @@ pub enum DefIdSource {
     // Identifies a region parameter (`fn foo<'X>() { ... }`).
     RegionParameter,
 
-    // Identifies an unboxed closure
-    UnboxedClosureSource
+    // Identifies a closure
+    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;
@@ -448,10 +448,8 @@ impl tr for def::Def {
           def::DefPrimTy(p) => def::DefPrimTy(p),
           def::DefTyParam(s, index, def_id, n) => def::DefTyParam(s, index, def_id.tr(dcx), n),
           def::DefUse(did) => def::DefUse(did.tr(dcx)),
-          def::DefUpvar(nid1, nid2, nid3) => {
-            def::DefUpvar(dcx.tr_id(nid1),
-                           dcx.tr_id(nid2),
-                           dcx.tr_id(nid3))
+          def::DefUpvar(nid1, nid2) => {
+            def::DefUpvar(dcx.tr_id(nid1), dcx.tr_id(nid2))
           }
           def::DefStruct(did) => def::DefStruct(did.tr(dcx)),
           def::DefRegion(nid) => def::DefRegion(dcx.tr_id(nid)),
@@ -618,8 +616,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 +641,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 +733,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 +760,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 +862,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 +1319,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 +1363,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 +1430,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 +1441,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 +1791,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 +1802,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 +1858,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 +1953,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(