convert the closure_kinds map to just store the origin information

The closure kinds themselves are now completely found in the `ClosureSubsts`.

Author: nikomatsakis

src/librustc/lib.rs

@@ -49,6 +49,7 @@
 #![feature(inclusive_range_syntax)]
 #![cfg_attr(windows, feature(libc))]
 #![feature(macro_vis_matcher)]
+#![feature(match_default_bindings)]
 #![feature(never_type)]
 #![feature(nonzero)]
 #![feature(quote)]

src/librustc/middle/mem_categorization.rs

@@ -753,16 +753,16 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
             ty::TyClosure(closure_def_id, closure_substs) => {
                 match self.infcx {
                     // During upvar inference we may not know the
-                    // closure kind, just use `Fn`.
+                    // closure kind, just use the LATTICE_BOTTOM value.
                     Some(infcx) =>
                         infcx.closure_kind(closure_def_id, closure_substs)
-                             .unwrap_or(ty::ClosureKind::Fn),
+                             .unwrap_or(ty::ClosureKind::LATTICE_BOTTOM),
 
                     None =>
                         self.tcx.global_tcx()
                                 .lift(&closure_substs)
                                 .expect("no inference cx, but inference variables in closure ty")
-                                .closure_kind(closure_def_id, self.tcx.global_tcx())
+                                .closure_kind(closure_def_id, self.tcx.global_tcx()),
                 }
             }
             ref t => bug!("upvar from non-closure and non-generator: {:?}", t)

src/librustc/traits/error_reporting.rs

@@ -674,14 +674,14 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                         if let Some(tables) = self.in_progress_tables {
                             let tables = tables.borrow();
                             let closure_hir_id = self.tcx.hir.node_to_hir_id(node_id);
-                            match tables.closure_kinds().get(closure_hir_id) {
-                                Some(&(ty::ClosureKind::FnOnce, Some((span, name)))) => {
-                                    err.span_note(span, &format!(
+                            match (found_kind, tables.closure_kind_origins().get(closure_hir_id)) {
+                                (ty::ClosureKind::FnOnce, Some((span, name))) => {
+                                    err.span_note(*span, &format!(
                                         "closure is `FnOnce` because it moves the \
                                          variable `{}` out of its environment", name));
                                 },
-                                Some(&(ty::ClosureKind::FnMut, Some((span, name)))) => {
-                                    err.span_note(span, &format!(
+                                (ty::ClosureKind::FnMut, Some((span, name))) => {
+                                    err.span_note(*span, &format!(
                                         "closure is `FnMut` because it mutates the \
                                          variable `{}` here", name));
                                 },

src/librustc/ty/context.rs

@@ -360,9 +360,9 @@ pub struct TypeckTables<'tcx> {
     /// Records the type of each closure.
     closure_tys: ItemLocalMap<ty::PolyFnSig<'tcx>>,
 
-    /// Records the kind of each closure and the span and name of the variable
-    /// that caused the closure to be this kind.
-    closure_kinds: ItemLocalMap<(ty::ClosureKind, Option<(Span, ast::Name)>)>,
+    /// Records the reasons that we picked the kind of each closure;
+    /// not all closures are present in the map.
+    closure_kind_origins: ItemLocalMap<(Span, ast::Name)>,
 
     generator_sigs: ItemLocalMap<Option<ty::GenSig<'tcx>>>,
 
@@ -415,7 +415,7 @@ impl<'tcx> TypeckTables<'tcx> {
             generator_sigs: ItemLocalMap(),
             generator_interiors: ItemLocalMap(),
             closure_tys: ItemLocalMap(),
-            closure_kinds: ItemLocalMap(),
+            closure_kind_origins: ItemLocalMap(),
             liberated_fn_sigs: ItemLocalMap(),
             fru_field_types: ItemLocalMap(),
             cast_kinds: ItemLocalMap(),
@@ -625,19 +625,17 @@ impl<'tcx> TypeckTables<'tcx> {
         }
     }
 
-    pub fn closure_kinds(&self) -> LocalTableInContext<(ty::ClosureKind,
-                                                        Option<(Span, ast::Name)>)> {
+    pub fn closure_kind_origins(&self) -> LocalTableInContext<(Span, ast::Name)> {
         LocalTableInContext {
             local_id_root: self.local_id_root,
-            data: &self.closure_kinds
+            data: &self.closure_kind_origins
         }
     }
 
-    pub fn closure_kinds_mut(&mut self)
-            -> LocalTableInContextMut<(ty::ClosureKind, Option<(Span, ast::Name)>)> {
+    pub fn closure_kind_origins_mut(&mut self) -> LocalTableInContextMut<(Span, ast::Name)> {
         LocalTableInContextMut {
             local_id_root: self.local_id_root,
-            data: &mut self.closure_kinds
+            data: &mut self.closure_kind_origins
         }
     }
 
@@ -734,7 +732,7 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for TypeckTables<'gcx> {
             ref pat_adjustments,
             ref upvar_capture_map,
             ref closure_tys,
-            ref closure_kinds,
+            ref closure_kind_origins,
             ref liberated_fn_sigs,
             ref fru_field_types,
 
@@ -777,7 +775,7 @@ impl<'gcx> HashStable<StableHashingContext<'gcx>> for TypeckTables<'gcx> {
             });
 
             closure_tys.hash_stable(hcx, hasher);
-            closure_kinds.hash_stable(hcx, hasher);
+            closure_kind_origins.hash_stable(hcx, hasher);
             liberated_fn_sigs.hash_stable(hcx, hasher);
             fru_field_types.hash_stable(hcx, hasher);
             cast_kinds.hash_stable(hcx, hasher);

src/librustc/ty/mod.rs

@@ -1902,6 +1902,9 @@ pub enum ClosureKind {
 }
 
 impl<'a, 'tcx> ClosureKind {
+    // This is the initial value used when doing upvar inference.
+    pub const LATTICE_BOTTOM: ClosureKind = ClosureKind::Fn;
+
     pub fn trait_did(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> DefId {
         match *self {
             ClosureKind::Fn => tcx.require_lang_item(FnTraitLangItem),

src/librustc_borrowck/borrowck/mod.rs

@@ -655,10 +655,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                     ty::TypeVariants::TyClosure(id, _) => {
                         let node_id = self.tcx.hir.as_local_node_id(id).unwrap();
                         let hir_id = self.tcx.hir.node_to_hir_id(node_id);
-                        if let Some(&(ty::ClosureKind::FnOnce, Some((span, name)))) =
-                            self.tables.closure_kinds().get(hir_id)
-                        {
-                            err.span_note(span, &format!(
+                        if let Some((span, name)) = self.tables.closure_kind_origins().get(hir_id) {
+                            err.span_note(*span, &format!(
                                 "closure cannot be invoked more than once because \
                                 it moves the variable `{}` out of its environment",
                                 name

src/librustc_borrowck/lib.rs

@@ -15,6 +15,7 @@
 
 #![allow(non_camel_case_types)]
 
+#![feature(match_default_bindings)]
 #![feature(quote)]
 
 #[macro_use] extern crate log;

src/librustc_typeck/check/closure.rs

@@ -140,7 +140,6 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 
         self.tables.borrow_mut().closure_tys_mut().insert(expr.hir_id, sig);
         if let Some(kind) = opt_kind {
-            self.tables.borrow_mut().closure_kinds_mut().insert(expr.hir_id, (kind, None));
             self.demand_eqtype(expr.span,
                                kind.to_ty(self.tcx),
                                substs.closure_kind_ty(expr_def_id, self.tcx));

src/librustc_typeck/check/upvar.rs

@@ -45,16 +45,14 @@ use super::FnCtxt;
 use middle::expr_use_visitor as euv;
 use middle::mem_categorization as mc;
 use middle::mem_categorization::Categorization;
+use rustc::hir::def_id::DefId;
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::infer::UpvarRegion;
 use syntax::ast;
 use syntax_pos::Span;
 use rustc::hir;
 use rustc::hir::def_id::DefIndex;
 use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
-use rustc::util::nodemap::FxHashMap;
-
-use std::collections::hash_map::Entry;
 
 impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     pub fn closure_analyze(&self, body: &'gcx hir::Body) {
@@ -98,7 +96,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         span: Span,
         body: &hir::Body,
         capture_clause: hir::CaptureClause,
-        gen: bool,
+        is_generator: bool,
     ) {
         /*!
          * Analysis starting point.
@@ -110,24 +108,24 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             body.id()
         );
 
-        let infer_kind = if gen {
-            false
-        } else {
-            match self.tables
-                .borrow_mut()
-                .closure_kinds_mut()
-                .entry(closure_hir_id)
-            {
-                Entry::Occupied(_) => false,
-                Entry::Vacant(entry) => {
-                    debug!("check_closure: adding closure {:?} as Fn", closure_node_id);
-                    entry.insert((ty::ClosureKind::Fn, None));
-                    true
-                }
+        // Extract the type of the closure.
+        let (closure_def_id, closure_substs) = match self.node_ty(closure_hir_id).sty {
+            ty::TyClosure(def_id, substs) | ty::TyGenerator(def_id, substs, _) => (def_id, substs),
+            ref t => {
+                span_bug!(
+                    span,
+                    "type of closure expr {:?} is not a closure {:?}",
+                    closure_node_id,
+                    t
+                );
             }
         };
 
-        let closure_def_id = self.tcx.hir.local_def_id(closure_node_id);
+        let infer_kind = if is_generator {
+            false
+        } else {
+            self.closure_kind(closure_def_id, closure_substs).is_none()
+        };
 
         self.tcx
             .with_freevars(closure_node_id, |freevars| for freevar in freevars {
@@ -156,24 +154,13 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     .insert(upvar_id, capture_kind);
             });
 
-        // Extract the type of the closure.
-        let (def_id, closure_substs) = match self.node_ty(closure_hir_id).sty {
-            ty::TyClosure(def_id, substs) | ty::TyGenerator(def_id, substs, _) => (def_id, substs),
-            ref t => {
-                span_bug!(
-                    span,
-                    "type of closure expr {:?} is not a closure {:?}",
-                    closure_node_id,
-                    t
-                );
-            }
-        };
-
         let body_owner_def_id = self.tcx.hir.body_owner_def_id(body.id());
         let region_scope_tree = &self.tcx.region_scope_tree(body_owner_def_id);
         let mut delegate = InferBorrowKind {
             fcx: self,
-            adjust_closure_kinds: FxHashMap(),
+            closure_def_id: closure_def_id,
+            current_closure_kind: ty::ClosureKind::LATTICE_BOTTOM,
+            current_origin: None,
             adjust_upvar_captures: ty::UpvarCaptureMap::default(),
         };
         euv::ExprUseVisitor::with_infer(
@@ -184,22 +171,19 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             &self.tables.borrow(),
         ).consume_body(body);
 
-        // Write the adjusted values back into the main tables.
         if infer_kind {
-            let opt_adjusted = delegate.adjust_closure_kinds.remove(&closure_def_id.index);
-            let closure_kind_ty = closure_substs.closure_kind_ty(def_id, self.tcx);
-            if let Some((kind, origin)) = opt_adjusted {
+            // Unify the (as yet unbound) type variable in the closure
+            // substs with the kind we inferred.
+            let inferred_kind = delegate.current_closure_kind;
+            let closure_kind_ty = closure_substs.closure_kind_ty(closure_def_id, self.tcx);
+            self.demand_eqtype(span, inferred_kind.to_ty(self.tcx), closure_kind_ty);
+
+            // If we have an origin, store it.
+            if let Some(origin) = delegate.current_origin {
                 self.tables
                     .borrow_mut()
-                    .closure_kinds_mut()
-                    .insert(closure_hir_id, (kind, origin));
-
-                self.demand_eqtype(span, kind.to_ty(self.tcx), closure_kind_ty);
-            } else {
-                // If there are only reads, or no upvars, then the
-                // default of `Fn` will never *have* to be adjusted, so there will be
-                // no entry in the map.
-                self.demand_eqtype(span, ty::ClosureKind::Fn.to_ty(self.tcx), closure_kind_ty);
+                    .closure_kind_origins_mut()
+                    .insert(closure_hir_id, origin);
             }
         }
 
@@ -229,19 +213,17 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             final_upvar_tys
         );
         for (upvar_ty, final_upvar_ty) in closure_substs
-            .upvar_tys(def_id, self.tcx)
+            .upvar_tys(closure_def_id, self.tcx)
             .zip(final_upvar_tys)
         {
             self.demand_eqtype(span, final_upvar_ty, upvar_ty);
         }
 
         // If we are also inferred the closure kind here,
         // process any deferred resolutions.
-        if infer_kind {
-            let deferred_call_resolutions = self.remove_deferred_call_resolutions(closure_def_id);
-            for deferred_call_resolution in deferred_call_resolutions {
-                deferred_call_resolution.resolve(self);
-            }
+        let deferred_call_resolutions = self.remove_deferred_call_resolutions(closure_def_id);
+        for deferred_call_resolution in deferred_call_resolutions {
+            deferred_call_resolution.resolve(self);
         }
     }
 
@@ -293,7 +275,24 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 
 struct InferBorrowKind<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
     fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
-    adjust_closure_kinds: FxHashMap<DefIndex, (ty::ClosureKind, Option<(Span, ast::Name)>)>,
+
+    // The def-id of the closure whose kind and upvar accesses are being inferred.
+    closure_def_id: DefId,
+
+    // The kind that we have inferred that the current closure
+    // requires. Note that we *always* infer a minimal kind, even if
+    // we don't always *use* that in the final result (i.e., sometimes
+    // we've taken the closure kind from the expectations instead, and
+    // for generators we don't even implement the closure traits
+    // really).
+    current_closure_kind: ty::ClosureKind,
+
+    // If we modified `current_closure_kind`, this field contains a `Some()` with the
+    // variable access that caused us to do so.
+    current_origin: Option<(Span, ast::Name)>,
+
+    // For each upvar that we access, we track the minimal kind of
+    // access we need (ref, ref mut, move, etc).
     adjust_upvar_captures: ty::UpvarCaptureMap<'tcx>,
 }
 
@@ -533,42 +532,36 @@ impl<'a, 'gcx, 'tcx> InferBorrowKind<'a, 'gcx, 'tcx> {
             var_name
         );
 
-        let closure_kind = self.adjust_closure_kinds
-            .get(&closure_id)
-            .cloned()
-            .or_else(|| {
-                let closure_id = self.fcx.tcx.hir.def_index_to_hir_id(closure_id);
-                self.fcx
-                    .tables
-                    .borrow()
-                    .closure_kinds()
-                    .get(closure_id)
-                    .cloned()
-            });
+        // Is this the closure whose kind is currently being inferred?
+        if DefId::local(closure_id) != self.closure_def_id {
+            debug!("adjust_closure_kind: not current closure");
+            return;
+        }
 
-        if let Some((existing_kind, _)) = closure_kind {
-            debug!(
-                "adjust_closure_kind: closure_id={:?}, existing_kind={:?}, new_kind={:?}",
-                closure_id,
-                existing_kind,
-                new_kind
-            );
-
-            match (existing_kind, new_kind) {
-                (ty::ClosureKind::Fn, ty::ClosureKind::Fn) |
-                (ty::ClosureKind::FnMut, ty::ClosureKind::Fn) |
-                (ty::ClosureKind::FnMut, ty::ClosureKind::FnMut) |
-                (ty::ClosureKind::FnOnce, _) => {
-                    // no change needed
-                }
+        // closures start out as `Fn`.
+        let existing_kind = self.current_closure_kind;
 
-                (ty::ClosureKind::Fn, ty::ClosureKind::FnMut) |
-                (ty::ClosureKind::Fn, ty::ClosureKind::FnOnce) |
-                (ty::ClosureKind::FnMut, ty::ClosureKind::FnOnce) => {
-                    // new kind is stronger than the old kind
-                    self.adjust_closure_kinds
-                        .insert(closure_id, (new_kind, Some((upvar_span, var_name))));
-                }
+        debug!(
+            "adjust_closure_kind: closure_id={:?}, existing_kind={:?}, new_kind={:?}",
+            closure_id,
+            existing_kind,
+            new_kind
+        );
+
+        match (existing_kind, new_kind) {
+            (ty::ClosureKind::Fn, ty::ClosureKind::Fn) |
+            (ty::ClosureKind::FnMut, ty::ClosureKind::Fn) |
+            (ty::ClosureKind::FnMut, ty::ClosureKind::FnMut) |
+            (ty::ClosureKind::FnOnce, _) => {
+                // no change needed
+            }
+
+            (ty::ClosureKind::Fn, ty::ClosureKind::FnMut) |
+            (ty::ClosureKind::Fn, ty::ClosureKind::FnOnce) |
+            (ty::ClosureKind::FnMut, ty::ClosureKind::FnOnce) => {
+                // new kind is stronger than the old kind
+                self.current_closure_kind = new_kind;
+                self.current_origin = Some((upvar_span, var_name));
             }
         }
     }