rustc: rename all occurences of "freevar" to "upvar".

eddyb · eddyb · commit 8d9f4a128c4c · 2019-05-05T18:49:32.000+03:00
diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs
@@ -140,7 +140,7 @@ pub enum Res<Id = hir::HirId> {
     SelfCtor(DefId /* impl */),  // `DefId` refers to the impl
     Local(Id),
     Upvar(Id,           // `HirId` of closed over local
-          usize,        // index in the `freevars` list of the closure
+          usize,        // index in the `upvars` list of the closure
           ast::NodeId), // expr node that creates the closure
 
     // Macro namespace
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
@@ -2476,19 +2476,19 @@ impl ForeignItemKind {
     }
 }
 
-/// A free variable referred to in a function.
+/// A variable captured by a closure.
 #[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub struct Freevar<Id = HirId> {
-    /// The variable being accessed free.
+pub struct Upvar<Id = HirId> {
+    /// The variable being captured.
     pub res: Res<Id>,
 
     // First span where it is accessed (there can be multiple).
     pub span: Span
 }
 
-impl<Id: fmt::Debug + Copy> Freevar<Id> {
-    pub fn map_id<R>(self, map: impl FnMut(Id) -> R) -> Freevar<R> {
-        Freevar {
+impl<Id: fmt::Debug + Copy> Upvar<Id> {
+    pub fn map_id<R>(self, map: impl FnMut(Id) -> R) -> Upvar<R> {
+        Upvar {
             res: self.res.map_id(map),
             span: self.span,
         }
@@ -2497,12 +2497,12 @@ impl<Id: fmt::Debug + Copy> Freevar<Id> {
     pub fn var_id(&self) -> Id {
         match self.res {
             Res::Local(id) | Res::Upvar(id, ..) => id,
-            _ => bug!("Freevar::var_id: bad res ({:?})", self.res)
+            _ => bug!("Upvar::var_id: bad res ({:?})", self.res)
         }
     }
 }
 
-pub type FreevarMap = NodeMap<Vec<Freevar<ast::NodeId>>>;
+pub type UpvarMap = NodeMap<Vec<Upvar<ast::NodeId>>>;
 
 pub type CaptureModeMap = NodeMap<CaptureClause>;
 
diff --git a/src/librustc/infer/error_reporting/note.rs b/src/librustc/infer/error_reporting/note.rs
@@ -46,7 +46,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 err.span_note(span,
                               "...so that pointer is not dereferenced outside its lifetime");
             }
-            infer::FreeVariable(span, id) => {
+            infer::ClosureCapture(span, id) => {
                 err.span_note(span,
                               &format!("...so that captured variable `{}` does not outlive the \
                                         enclosing closure",
@@ -214,7 +214,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     "the reference is only valid for ", sup, "");
                 err
             }
-            infer::FreeVariable(span, id) => {
+            infer::ClosureCapture(span, id) => {
                 let mut err = struct_span_err!(self.tcx.sess,
                                                span,
                                                E0474,
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
@@ -264,8 +264,8 @@ pub enum SubregionOrigin<'tcx> {
     /// Dereference of reference must be within its lifetime
     DerefPointer(Span),
 
-    /// Closure bound must not outlive captured free variables
-    FreeVariable(Span, ast::NodeId),
+    /// Closure bound must not outlive captured variables
+    ClosureCapture(Span, ast::NodeId),
 
     /// Index into slice must be within its lifetime
     IndexSlice(Span),
@@ -1660,7 +1660,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
             InfStackClosure(a) => a,
             InvokeClosure(a) => a,
             DerefPointer(a) => a,
-            FreeVariable(a, _) => a,
+            ClosureCapture(a, _) => a,
             IndexSlice(a) => a,
             RelateObjectBound(a) => a,
             RelateParamBound(a, _) => a,
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
@@ -931,32 +931,32 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
         debug!("walk_captures({:?})", closure_expr);
 
         let closure_def_id = self.tcx().hir().local_def_id_from_hir_id(closure_expr.hir_id);
-        if let Some(freevars) = self.tcx().freevars(closure_def_id) {
-            for freevar in freevars.iter() {
-                let var_hir_id = freevar.var_id();
+        if let Some(upvars) = self.tcx().upvars(closure_def_id) {
+            for upvar in upvars.iter() {
+                let var_hir_id = upvar.var_id();
                 let upvar_id = ty::UpvarId {
                     var_path: ty::UpvarPath { hir_id: var_hir_id },
                     closure_expr_id: closure_def_id.to_local(),
                 };
                 let upvar_capture = self.mc.tables.upvar_capture(upvar_id);
                 let cmt_var = return_if_err!(self.cat_captured_var(closure_expr.hir_id,
                                                                    fn_decl_span,
-                                                                   freevar));
+                                                                   upvar));
                 match upvar_capture {
                     ty::UpvarCapture::ByValue => {
                         let mode = copy_or_move(&self.mc,
                                                 self.param_env,
                                                 &cmt_var,
                                                 CaptureMove);
-                        self.delegate.consume(closure_expr.hir_id, freevar.span, &cmt_var, mode);
+                        self.delegate.consume(closure_expr.hir_id, upvar.span, &cmt_var, mode);
                     }
                     ty::UpvarCapture::ByRef(upvar_borrow) => {
                         self.delegate.borrow(closure_expr.hir_id,
                                              fn_decl_span,
                                              &cmt_var,
                                              upvar_borrow.region,
                                              upvar_borrow.kind,
-                                             ClosureCapture(freevar.span));
+                                             ClosureCapture(upvar.span));
                     }
                 }
             }
@@ -966,7 +966,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
     fn cat_captured_var(&mut self,
                         closure_hir_id: hir::HirId,
                         closure_span: Span,
-                        upvar: &hir::Freevar)
+                        upvar: &hir::Upvar)
                         -> mc::McResult<mc::cmt_<'tcx>> {
         // Create the cmt for the variable being borrowed, from the
         // caller's perspective
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
@@ -144,7 +144,7 @@ impl LiveNode {
 
 #[derive(Copy, Clone, PartialEq, Debug)]
 enum LiveNodeKind {
-    FreeVarNode(Span),
+    UpvarNode(Span),
     ExprNode(Span),
     VarDefNode(Span),
     ExitNode
@@ -153,8 +153,8 @@ enum LiveNodeKind {
 fn live_node_kind_to_string(lnk: LiveNodeKind, tcx: TyCtxt<'_, '_, '_>) -> String {
     let cm = tcx.sess.source_map();
     match lnk {
-        FreeVarNode(s) => {
-            format!("Free var node [{}]", cm.span_to_string(s))
+        UpvarNode(s) => {
+            format!("Upvar node [{}]", cm.span_to_string(s))
         }
         ExprNode(s) => {
             format!("Expr node [{}]", cm.span_to_string(s))
@@ -484,11 +484,11 @@ fn visit_expr<'a, 'tcx>(ir: &mut IrMaps<'a, 'tcx>, expr: &'tcx Expr) {
         // construction site.
         let mut call_caps = Vec::new();
         let closure_def_id = ir.tcx.hir().local_def_id_from_hir_id(expr.hir_id);
-        if let Some(freevars) = ir.tcx.freevars(closure_def_id) {
-            call_caps.extend(freevars.iter().filter_map(|freevar| {
-                if let Res::Local(rv) = freevar.res {
-                    let freevar_ln = ir.add_live_node(FreeVarNode(freevar.span));
-                    Some(CaptureInfo { ln: freevar_ln, var_hid: rv })
+        if let Some(upvars) = ir.tcx.upvars(closure_def_id) {
+            call_caps.extend(upvars.iter().filter_map(|upvar| {
+                if let Res::Local(rv) = upvar.res {
+                    let upvar_ln = ir.add_live_node(UpvarNode(upvar.span));
+                    Some(CaptureInfo { ln: upvar_ln, var_hid: rv })
                 } else {
                     None
                 }
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
@@ -2572,9 +2572,9 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                             };
                             let mut struct_fmt = fmt.debug_struct(&name);
 
-                            if let Some(freevars) = tcx.freevars(def_id) {
-                                for (freevar, place) in freevars.iter().zip(places) {
-                                    let var_name = tcx.hir().name_by_hir_id(freevar.var_id());
+                            if let Some(upvars) = tcx.upvars(def_id) {
+                                for (upvar, place) in upvars.iter().zip(places) {
+                                    let var_name = tcx.hir().name_by_hir_id(upvar.var_id());
                                     struct_fmt.field(&var_name.as_str(), place);
                                 }
                             }
@@ -2591,9 +2591,9 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                                                tcx.hir().span_by_hir_id(hir_id));
                             let mut struct_fmt = fmt.debug_struct(&name);
 
-                            if let Some(freevars) = tcx.freevars(def_id) {
-                                for (freevar, place) in freevars.iter().zip(places) {
-                                    let var_name = tcx.hir().name_by_hir_id(freevar.var_id());
+                            if let Some(upvars) = tcx.upvars(def_id) {
+                                for (upvar, place) in upvars.iter().zip(places) {
+                                    let var_name = tcx.hir().name_by_hir_id(upvar.var_id());
                                     struct_fmt.field(&var_name.as_str(), place);
                                 }
                             }
diff --git a/src/librustc/query/mod.rs b/src/librustc/query/mod.rs
@@ -824,7 +824,7 @@ rustc_queries! {
             desc { "generating a postorder list of CrateNums" }
         }
 
-        query freevars(_: DefId) -> Option<Lrc<Vec<hir::Freevar>>> {
+        query upvars(_: DefId) -> Option<Lrc<Vec<hir::Upvar>>> {
             eval_always
         }
         query maybe_unused_trait_import(_: DefId) -> bool {
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -1071,10 +1071,10 @@ pub struct GlobalCtxt<'tcx> {
 
     pub queries: query::Queries<'tcx>,
 
-    // Records the free variables referenced by every closure
+    // Records the captured variables referenced by every closure
     // expression. Do not track deps for this, just recompute it from
     // scratch every time.
-    freevars: FxHashMap<DefId, Lrc<Vec<hir::Freevar>>>,
+    upvars: FxHashMap<DefId, Lrc<Vec<hir::Upvar>>>,
 
     maybe_unused_trait_imports: FxHashSet<DefId>,
     maybe_unused_extern_crates: Vec<(DefId, Span)>,
@@ -1317,7 +1317,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                 }).collect();
                 (k, Lrc::new(exports))
             }).collect(),
-            freevars: resolutions.freevars.into_iter().map(|(k, v)| {
+            upvars: resolutions.upvars.into_iter().map(|(k, v)| {
                 let vars: Vec<_> = v.into_iter().map(|e| {
                     e.map_id(|id| hir.node_to_hir_id(id))
                 }).collect();
@@ -3055,7 +3055,7 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
         assert_eq!(id, LOCAL_CRATE);
         Lrc::new(middle::lang_items::collect(tcx))
     };
-    providers.freevars = |tcx, id| tcx.gcx.freevars.get(&id).cloned();
+    providers.upvars = |tcx, id| tcx.gcx.upvars.get(&id).cloned();
     providers.maybe_unused_trait_import = |tcx, id| {
         tcx.maybe_unused_trait_imports.contains(&id)
     };
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -8,7 +8,7 @@ pub use self::BorrowKind::*;
 pub use self::IntVarValue::*;
 pub use self::fold::TypeFoldable;
 
-use crate::hir::{map as hir_map, FreevarMap, GlobMap, TraitMap};
+use crate::hir::{map as hir_map, UpvarMap, GlobMap, TraitMap};
 use crate::hir::Node;
 use crate::hir::def::{Res, DefKind, CtorOf, CtorKind, ExportMap};
 use crate::hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
@@ -122,7 +122,7 @@ mod sty;
 
 #[derive(Clone)]
 pub struct Resolutions {
-    pub freevars: FreevarMap,
+    pub upvars: UpvarMap,
     pub trait_map: TraitMap,
     pub maybe_unused_trait_imports: NodeSet,
     pub maybe_unused_extern_crates: Vec<(NodeId, Span)>,
diff --git a/src/librustc/ty/print/pretty.rs b/src/librustc/ty/print/pretty.rs
@@ -582,7 +582,7 @@ pub trait PrettyPrinter<'gcx: 'tcx, 'tcx>:
                 if let Some(hir_id) = self.tcx().hir().as_local_hir_id(did) {
                     p!(write("@{:?}", self.tcx().hir().span_by_hir_id(hir_id)));
                     let mut sep = " ";
-                    for (freevar, upvar_ty) in self.tcx().freevars(did)
+                    for (upvar, upvar_ty) in self.tcx().upvars(did)
                         .as_ref()
                         .map_or(&[][..], |v| &v[..])
                         .iter()
@@ -591,7 +591,7 @@ pub trait PrettyPrinter<'gcx: 'tcx, 'tcx>:
                         p!(
                             write("{}{}:",
                                     sep,
-                                    self.tcx().hir().name_by_hir_id(freevar.var_id())),
+                                    self.tcx().hir().name_by_hir_id(upvar.var_id())),
                             print(upvar_ty));
                         sep = ", ";
                     }
@@ -625,7 +625,7 @@ pub trait PrettyPrinter<'gcx: 'tcx, 'tcx>:
                         p!(write("@{:?}", self.tcx().hir().span_by_hir_id(hir_id)));
                     }
                     let mut sep = " ";
-                    for (freevar, upvar_ty) in self.tcx().freevars(did)
+                    for (upvar, upvar_ty) in self.tcx().upvars(did)
                         .as_ref()
                         .map_or(&[][..], |v| &v[..])
                         .iter()
@@ -634,7 +634,7 @@ pub trait PrettyPrinter<'gcx: 'tcx, 'tcx>:
                         p!(
                             write("{}{}:",
                                     sep,
-                                    self.tcx().hir().name_by_hir_id(freevar.var_id())),
+                                    self.tcx().hir().name_by_hir_id(upvar.var_id())),
                             print(upvar_ty));
                         sep = ", ";
                     }
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
@@ -180,7 +180,7 @@ impl ExpansionResult {
         ExpansionResult {
             defs: Steal::new(resolver.definitions),
             resolutions: Steal::new(Resolutions {
-                freevars: resolver.freevars,
+                upvars: resolver.upvars,
                 export_map: resolver.export_map,
                 trait_map: resolver.trait_map,
                 glob_map: resolver.glob_map,
@@ -199,7 +199,7 @@ impl ExpansionResult {
         ExpansionResult {
             defs: Steal::new(resolver.definitions.clone()),
             resolutions: Steal::new(Resolutions {
-                freevars: resolver.freevars.clone(),
+                upvars: resolver.upvars.clone(),
                 export_map: resolver.export_map.clone(),
                 trait_map: resolver.trait_map.clone(),
                 glob_map: resolver.glob_map.clone(),
diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs
@@ -1814,12 +1814,12 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
                 ty::Array(ty, _) | ty::Slice(ty) =>
                     self.describe_field_from_ty(&ty, field, variant_index),
                 ty::Closure(def_id, _) | ty::Generator(def_id, _, _) => {
-                    // `tcx.freevars(def_id)` returns an `Option`, which is `None` in case
+                    // `tcx.upvars(def_id)` returns an `Option`, which is `None` in case
                     // the closure comes from another crate. But in that case we wouldn't
                     // be borrowck'ing it, so we can just unwrap:
-                    let freevar = self.infcx.tcx.freevars(def_id).unwrap()[field.index()];
+                    let upvar = self.infcx.tcx.upvars(def_id).unwrap()[field.index()];
 
-                    self.infcx.tcx.hir().name_by_hir_id(freevar.var_id()).to_string()
+                    self.infcx.tcx.hir().name_by_hir_id(upvar.var_id()).to_string()
                 }
                 _ => {
                     // Might need a revision when the fields in trait RFC is implemented
@@ -2609,7 +2609,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         if let hir::ExprKind::Closure(
             .., args_span, _
         ) = expr {
-            for (v, place) in self.infcx.tcx.freevars(def_id)?.iter().zip(places) {
+            for (v, place) in self.infcx.tcx.upvars(def_id)?.iter().zip(places) {
                 match place {
                     Operand::Copy(place) |
                     Operand::Move(place) if target_place == place => {
diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs
@@ -516,10 +516,10 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
                     span_bug!(expr.span, "closure expr w/o closure type: {:?}", closure_ty);
                 }
             };
-            let upvars = cx.tcx.freevars(def_id).iter()
-                .flat_map(|freevars| freevars.iter())
+            let upvars = cx.tcx.upvars(def_id).iter()
+                .flat_map(|upvars| upvars.iter())
                 .zip(substs.upvar_tys(def_id, cx.tcx))
-                .map(|(freevar, ty)| capture_freevar(cx, expr, freevar, ty))
+                .map(|(upvar, ty)| capture_upvar(cx, expr, upvar, ty))
                 .collect();
             ExprKind::Closure {
                 closure_id: def_id,
@@ -1184,12 +1184,12 @@ fn overloaded_place<'a, 'gcx, 'tcx>(
     ExprKind::Deref { arg: ref_expr.to_ref() }
 }
 
-fn capture_freevar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
+fn capture_upvar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
                                    closure_expr: &'tcx hir::Expr,
-                                   freevar: &hir::Freevar,
-                                   freevar_ty: Ty<'tcx>)
+                                   upvar: &hir::Upvar,
+                                   upvar_ty: Ty<'tcx>)
                                    -> ExprRef<'tcx> {
-    let var_hir_id = freevar.var_id();
+    let var_hir_id = upvar.var_id();
     let upvar_id = ty::UpvarId {
         var_path: ty::UpvarPath { hir_id: var_hir_id },
         closure_expr_id: cx.tcx.hir().local_def_id_from_hir_id(closure_expr.hir_id).to_local(),
@@ -1201,7 +1201,7 @@ fn capture_freevar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
         temp_lifetime,
         ty: var_ty,
         span: closure_expr.span,
-        kind: convert_var(cx, closure_expr, freevar.res),
+        kind: convert_var(cx, closure_expr, upvar.res),
     };
     match upvar_capture {
         ty::UpvarCapture::ByValue => captured_var.to_ref(),
@@ -1213,7 +1213,7 @@ fn capture_freevar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
             };
             Expr {
                 temp_lifetime,
-                ty: freevar_ty,
+                ty: upvar_ty,
                 span: closure_expr.span,
                 kind: ExprKind::Borrow {
                     borrow_kind,
diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs
@@ -170,7 +170,7 @@ impl<'rt, 'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> ValidityVisitor<'rt, 'a, '
                 if def_id.is_local() {
                     let tables = self.ecx.tcx.typeck_tables_of(def_id);
                     if let Some(upvars) = tables.upvar_list.get(&def_id) {
-                        // Sometimes the index is beyond the number of freevars (seen
+                        // Sometimes the index is beyond the number of upvars (seen
                         // for a generator).
                         if let Some(upvar_id) = upvars.get(field) {
                             let var_hir_id = upvar_id.var_path.hir_id;
diff --git a/src/librustc_passes/rvalue_promotion.rs b/src/librustc_passes/rvalue_promotion.rs
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs
diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs

Original file line number	Diff line number	Diff line change
`@@ -2476,19 +2476,19 @@ impl ForeignItemKind {`
`2476`	`2476`	`}`
`2477`	`2477`	`}`
`2478`	`2478`
`2479`		`-/// A free variable referred to in a function.`
	`2479`	`+/// A variable captured by a closure.`
`2480`	`2480`	`#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)]`
`2481`		`-pub struct Freevar<Id = HirId> {`
`2482`		`- /// The variable being accessed free.`
	`2481`	`+pub struct Upvar<Id = HirId> {`
	`2482`	`+ /// The variable being captured.`
`2483`	`2483`	`pub res: Res<Id>,`
`2484`	`2484`
`2485`	`2485`	`// First span where it is accessed (there can be multiple).`
`2486`	`2486`	`pub span: Span`
`2487`	`2487`	`}`
`2488`	`2488`
`2489`		`-impl<Id: fmt::Debug + Copy> Freevar<Id> {`
`2490`		`- pub fn map_id<R>(self, map: impl FnMut(Id) -> R) -> Freevar<R> {`
`2491`		`- Freevar {`
	`2489`	`+impl<Id: fmt::Debug + Copy> Upvar<Id> {`
	`2490`	`+ pub fn map_id<R>(self, map: impl FnMut(Id) -> R) -> Upvar<R> {`
	`2491`	`+ Upvar {`
`2492`	`2492`	`res: self.res.map_id(map),`
`2493`	`2493`	`span: self.span,`
`2494`	`2494`	`}`
`@@ -2497,12 +2497,12 @@ impl<Id: fmt::Debug + Copy> Freevar<Id> {`
`2497`	`2497`	`pub fn var_id(&self) -> Id {`
`2498`	`2498`	`match self.res {`
`2499`	`2499`	`Res::Local(id) \| Res::Upvar(id, ..) => id,`
`2500`		`- _ => bug!("Freevar::var_id: bad res ({:?})", self.res)`
	`2500`	`+ _ => bug!("Upvar::var_id: bad res ({:?})", self.res)`
`2501`	`2501`	`}`
`2502`	`2502`	`}`
`2503`	`2503`	`}`
`2504`	`2504`
`2505`		`-pub type FreevarMap = NodeMap<Vec<Freevar<ast::NodeId>>>;`
	`2505`	`+pub type UpvarMap = NodeMap<Vec<Upvar<ast::NodeId>>>;`
`2506`	`2506`
`2507`	`2507`	`pub type CaptureModeMap = NodeMap<CaptureClause>;`
`2508`	`2508`
Original file line number	Diff line number	Diff line change
`@@ -2572,9 +2572,9 @@ impl<'tcx> Debug for Rvalue<'tcx> {`
`2572`	`2572`	`};`
`2573`	`2573`	`let mut struct_fmt = fmt.debug_struct(&name);`
`2574`	`2574`
`2575`		`- if let Some(freevars) = tcx.freevars(def_id) {`
`2576`		`- for (freevar, place) in freevars.iter().zip(places) {`
`2577`		`- let var_name = tcx.hir().name_by_hir_id(freevar.var_id());`
	`2575`	`+ if let Some(upvars) = tcx.upvars(def_id) {`
	`2576`	`+ for (upvar, place) in upvars.iter().zip(places) {`
	`2577`	`+ let var_name = tcx.hir().name_by_hir_id(upvar.var_id());`
`2578`	`2578`	`struct_fmt.field(&var_name.as_str(), place);`
`2579`	`2579`	`}`
`2580`	`2580`	`}`
`@@ -2591,9 +2591,9 @@ impl<'tcx> Debug for Rvalue<'tcx> {`
`2591`	`2591`	`tcx.hir().span_by_hir_id(hir_id));`
`2592`	`2592`	`let mut struct_fmt = fmt.debug_struct(&name);`
`2593`	`2593`
`2594`		`- if let Some(freevars) = tcx.freevars(def_id) {`
`2595`		`- for (freevar, place) in freevars.iter().zip(places) {`
`2596`		`- let var_name = tcx.hir().name_by_hir_id(freevar.var_id());`
	`2594`	`+ if let Some(upvars) = tcx.upvars(def_id) {`
	`2595`	`+ for (upvar, place) in upvars.iter().zip(places) {`
	`2596`	`+ let var_name = tcx.hir().name_by_hir_id(upvar.var_id());`
`2597`	`2597`	`struct_fmt.field(&var_name.as_str(), place);`
`2598`	`2598`	`}`
`2599`	`2599`	`}`
Original file line number	Diff line number	Diff line change
`@@ -824,7 +824,7 @@ rustc_queries! {`
`824`	`824`	`desc { "generating a postorder list of CrateNums" }`
`825`	`825`	`}`
`826`	`826`
`827`		`- query freevars(_: DefId) -> Option<Lrc<Vec<hir::Freevar>>> {`
	`827`	`+ query upvars(_: DefId) -> Option<Lrc<Vec<hir::Upvar>>> {`
`828`	`828`	`eval_always`
`829`	`829`	`}`
`830`	`830`	`query maybe_unused_trait_import(_: DefId) -> bool {`