Adjust most comments and messages to not use "unboxed".

Author: eddyb

src/librustc/metadata/encoder.rs

@@ -2148,7 +2148,7 @@ 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_closures(&ecx, &mut rbml_w);
  stats.closure_bytes = rbml_w.writer.tell().unwrap() - i;
@@ -2193,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,7 +57,7 @@ pub enum DefIdSource {
  // Identifies a region parameter (`fn foo<'X>() { ... }`).
  RegionParameter,
 
- // Identifies an unboxed closure
+ // Identifies a closure
  ClosureSource
 }
 

src/librustc/middle/traits/mod.rs

@@ -232,10 +232,9 @@ pub enum Vtable<'tcx, N> {
  /// Successful resolution for a builtin trait.
  VtableBuiltin(VtableBuiltinData<N>),
 
- /// Vtable automatically generated for an unboxed closure. The def
- /// ID is the ID of the closure expression. This is a `VtableImpl`
- /// in spirit, but the impl is generated by the compiler and does
- /// not appear in the source.
+ /// Vtable automatically generated for a closure. The def ID is the ID
+ /// of the closure expression. This is a `VtableImpl` in spirit, but the
+ /// impl is generated by the compiler and does not appear in the source.
  VtableClosure(ast::DefId, subst::Substs<'tcx>),
 
  /// Same as above, but for a fn pointer type with the given signature.

src/librustc/middle/traits/select.rs

@@ -943,9 +943,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  }
 
  /// Check for the artificial impl that the compiler will create for an obligation like `X :
- /// FnMut<..>` where `X` is an unboxed closure type.
+ /// FnMut<..>` where `X` is a closure type.
  ///
- /// Note: the type parameters on an unboxed closure candidate are modeled as *output* type
+ /// Note: the type parameters on a closure candidate are modeled as *output* type
  /// parameters and hence do not affect whether this trait is a match or not. They will be
  /// unified during the confirmation step.
  fn assemble_closure_candidates(&mut self,
@@ -1932,7 +1932,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  trait_ref)
  }
 
- /// In the case of unboxed closure types and fn pointers,
+ /// In the case of closure types and fn pointers,
  /// we currently treat the input type parameters on the trait as
  /// outputs. This means that when we have a match we have only
  /// considered the self type, so we have to go back and make sure
@@ -1942,7 +1942,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  /// errors as if there is no applicable impl, but rather report
  /// errors are about mismatched argument types.
  ///
- /// Here is an example. Imagine we have an unboxed closure expression
+ /// Here is an example. Imagine we have an closure expression
  /// and we desugared it so that the type of the expression is
  /// `Closure`, and `Closure` expects an int as argument. Then it
  /// is "as if" the compiler generated this impl:

src/librustc/middle/ty.rs

@@ -432,7 +432,7 @@ pub enum MethodOrigin<'tcx> {
  // fully statically resolved method
  MethodStatic(ast::DefId),
 
- // fully statically resolved unboxed closure invocation
+ // fully statically resolved closure invocation
  MethodStaticClosure(ast::DefId),
 
  // method invoked on a type parameter with a bounded trait
@@ -565,7 +565,7 @@ pub enum vtable_origin<'tcx> {
  vtable_param(param_index, uint),
 
  /*
- Vtable automatically generated for an unboxed closure. The def ID is the
+ Vtable automatically generated for a closure. The def ID is the
  ID of the closure expression.
  */
  vtable_closure(ast::DefId),
@@ -785,8 +785,8 @@ pub struct ctxt<'tcx> {
 
  pub dependency_formats: RefCell<dependency_format::Dependencies>,
 
- /// Records the type of each unboxed closure. The def ID is the ID of the
- /// expression defining the unboxed closure.
+ /// Records the type of each closure. The def ID is the ID of the
+ /// expression defining the closure.
  pub closures: RefCell<DefIdMap<Closure<'tcx>>>,
 
  pub node_lint_levels: RefCell<FnvHashMap<(ast::NodeId, lint::LintId),
@@ -2262,12 +2262,12 @@ pub struct ItemSubsts<'tcx> {
  pub substs: Substs<'tcx>,
 }
 
-/// Records information about each unboxed closure.
+/// Records information about each closure.
 #[derive(Clone)]
 pub struct Closure<'tcx> {
- /// The type of the unboxed closure.
+ /// The type of the closure.
  pub closure_type: ClosureTy<'tcx>,
- /// The kind of unboxed closure this is.
+ /// The kind of closure this is.
  pub kind: ClosureKind,
 }
 
@@ -3416,8 +3416,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
  }
 
  ty_closure(did, r, substs) => {
- // FIXME(#14449): `borrowed_contents` below assumes `&mut`
- // unboxed closure.
+ // 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.as_slice(),
@@ -3685,7 +3684,7 @@ pub fn is_instantiable<'tcx>(cx: &ctxt<'tcx>, r_ty: Ty<'tcx>) -> bool {
  ty_infer(_) |
  ty_closure(..) => {
  // this check is run on type definitions, so we don't expect to see
- // inference by-products or unboxed closure types
+ // inference by-products or closure types
  cx.sess.bug(format!("requires check invoked on inapplicable type: {:?}",
  ty).as_slice())
  }
@@ -3778,8 +3777,8 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>)
  find_nonrepresentable(cx, sp, seen, iter)
  }
  ty_closure(..) => {
- // this check is run on type definitions, so we don't expect to see
- // unboxed closure types
+ // this check is run on type definitions, so we don't expect
+ // to see closure types
  cx.sess.bug(format!("requires check invoked on inapplicable type: {:?}",
  ty).as_slice())
  }

src/librustc_trans/trans/callee.rs

@@ -457,7 +457,7 @@ pub fn trans_fn_ref_with_substs<'a, 'tcx>(
  }
  };
 
- // If this is an unboxed closure, redirect to it.
+ // If this is a closure, redirect to it.
  match closure::get_or_create_declaration_if_closure(ccx, def_id, &substs) {
  None => {}
  Some(llfn) => return llfn,

src/librustc_trans/trans/closure.rs

@@ -133,14 +133,14 @@ impl<'a, 'tcx> ClosureEnv<'a, 'tcx> {
  }
 }
 
-/// Returns the LLVM function declaration for an unboxed closure, creating it
-/// if necessary. If the ID does not correspond to a closure ID, returns None.
- // Not an unboxed closure.
+/// Returns the LLVM function declaration for a closure, creating it if
+/// necessary. If the ID does not correspond to a closure ID, returns None.
 pub fn get_or_create_declaration_if_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
  closure_id: ast::DefId,
  substs: &Substs<'tcx>)
  -> Option<Datum<'tcx, Rvalue>> {
  if !ccx.tcx().closures.borrow().contains_key(&closure_id) {
+ // Not a closure.
  return None
  }
 
@@ -161,8 +161,7 @@ pub fn get_or_create_declaration_if_closure<'a, 'tcx>(ccx: &CrateContext<'a, 'tc
 
  match ccx.closure_vals().borrow().get(&mono_id) {
  Some(&llfn) => {
- debug!("get_or_create_declaration_if_closure(): found \
- closure");
+ debug!("get_or_create_declaration_if_closure(): found closure");
  return Some(Datum::new(llfn, function_type, Rvalue::new(ByValue)))
  }
  None => {}
@@ -230,8 +229,8 @@ pub fn trans_closure_expr<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
  Closure(freevar_mode)));
 
  // Don't hoist this to the top of the function. It's perfectly legitimate
- // to have a zero-size unboxed closure (in which case dest will be
- // `Ignore`) and we must still generate the closure body.
+ // to have a zero-size closure (in which case dest will be `Ignore`) and
+ // we must still generate the closure body.
  let dest_addr = match dest {
  expr::SaveIn(p) => p,
  expr::Ignore => {

src/librustc_trans/trans/expr.rs

@@ -1098,10 +1098,6 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
  tvec::trans_fixed_vstore(bcx, expr, dest)
  }
  ast::ExprClosure(_, _, ref decl, ref body) => {
- // Check the side-table to see whether this is an unboxed
- // closure or an older, legacy style closure. Store this
- // into a variable to ensure the the RefCell-lock is
- // released before we recurse.
  closure::trans_closure_expr(bcx, &**decl, &**body, expr.id, dest)
  }
  ast::ExprCall(ref f, ref args) => {

src/librustc_typeck/check/closure.rs

@@ -42,7 +42,7 @@ pub fn check_expr_closure<'a,'tcx>(fcx: &FnCtxt<'a,'tcx>,
  // If users didn't specify what sort of closure they want,
  // examine the expected type. For now, if we see explicit
  // evidence than an unboxed closure is desired, we'll use
- // that, otherwise we'll fall back to boxed closures.
+ // that, otherwise we'll error, requesting an annotation.
  match expected_sig_and_kind {
  None => { // don't have information about the kind, request explicit annotation
  // NB We still need to typeck the body, so assume `FnMut` kind just for that

src/librustc_typeck/check/method/probe.rs

@@ -603,7 +603,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
  None => {
  self.tcx().sess.span_bug(
  self.span,
- &format!("No entry for unboxed closure: {}",
+ &format!("No entry for closure: {}",
  closure_def_id.repr(self.tcx()))[]);
  }
  };