Add more safeguards to "missing binding mode" errors

src/librustc/middle/expr_use_visitor.rs

@@ -840,6 +840,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
     fn walk_pat(&mut self, cmt_discr: mc::cmt<'tcx>, pat: &hir::Pat, match_mode: MatchMode) {
         debug!("walk_pat(cmt_discr={:?}, pat={:?})", cmt_discr, pat);
 
+        let tcx = self.tcx();
         let ExprUseVisitor { ref mc, ref mut delegate, param_env } = *self;
         return_if_err!(mc.cat_pattern(cmt_discr.clone(), pat, |cmt_pat, pat| {
             if let PatKind::Binding(_, canonical_id, ..) = pat.node {
@@ -849,8 +850,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
                     pat,
                     match_mode,
                 );
-                let bm = *mc.tables.pat_binding_modes().get(pat.hir_id)
+                if let Some(&bm) = mc.tables.pat_binding_modes().get(pat.hir_id) {
-                                                     .expect("missing binding mode");
                     debug!("walk_pat: pat.hir_id={:?} bm={:?}", pat.hir_id, bm);
 
                     // pat_ty: the type of the binding being produced.
@@ -878,6 +878,9 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
                             delegate.consume_pat(pat, &cmt_pat, mode);
                         }
                     }
+                } else {
+                    tcx.sess.delay_span_bug(pat.span, "missing binding mode");
+                }
             }
         }));
 

src/librustc_borrowck/borrowck/unused.rs

@@ -54,16 +54,16 @@ impl<'a, 'tcx> UnusedMutCx<'a, 'tcx> {
 
                 // Skip anything that looks like `&foo` or `&mut foo`, only look
                 // for by-value bindings
-                let bm = match self.bccx.tables.pat_binding_modes().get(hir_id) {
+                if let Some(&bm) = self.bccx.tables.pat_binding_modes().get(hir_id) {
-                    Some(&bm) => bm,
-                    None => span_bug!(span, "missing binding mode"),
-                };
                     match bm {
                         ty::BindByValue(hir::MutMutable) => {}
                         _ => return,
                     }
 
                     mutables.entry(ident.name).or_insert(Vec::new()).push((hir_id, span));
+                } else {
+                    tcx.sess.delay_span_bug(span, "missing binding mode");
+                }
             });
         }
 

src/librustc_mir/build/mod.rs

@@ -541,14 +541,15 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
                 if let hir::PatKind::Binding(_, _, ident, _) = pat.node {
                     decl.debug_name = ident.name;
 
-                    let bm = *hir.tables.pat_binding_modes()
+                    if let Some(&bm) = hir.tables.pat_binding_modes().get(pat.hir_id) {
-                                        .get(pat.hir_id)
-                                        .expect("missing binding mode");
                         if bm == ty::BindByValue(hir::MutMutable) {
                             decl.mutability = Mutability::Mut;
                         } else {
                             decl.mutability = Mutability::Not;
                         }
+                    } else {
+                        tcx.sess.delay_span_bug(pat.span, "missing binding mode");
+                    }
                 }
             }
             decl

src/librustc_mir/hair/pattern/check_match.rs

@@ -516,13 +516,13 @@ fn check_legality_of_move_bindings(cx: &MatchVisitor,
     let mut by_ref_span = None;
     for pat in pats {
         pat.each_binding(|_, hir_id, span, _path| {
-            let bm = *cx.tables
+            if let Some(&bm) = cx.tables.pat_binding_modes().get(hir_id) {
-                        .pat_binding_modes()
-                        .get(hir_id)
-                        .expect("missing binding mode");
                 if let ty::BindByReference(..) = bm {
                     by_ref_span = Some(span);
                 }
+            } else {
+                cx.tcx.sess.delay_span_bug(pat.span, "missing binding mode");
+            }
         })
     }
 
@@ -552,10 +552,7 @@ fn check_legality_of_move_bindings(cx: &MatchVisitor,
     for pat in pats {
         pat.walk(|p| {
             if let PatKind::Binding(_, _, _, ref sub) = p.node {
-                let bm = *cx.tables
+                if let Some(&bm) = cx.tables.pat_binding_modes().get(p.hir_id) {
-                            .pat_binding_modes()
-                            .get(p.hir_id)
-                            .expect("missing binding mode");
                     match bm {
                         ty::BindByValue(..) => {
                             let pat_ty = cx.tables.node_id_to_type(p.hir_id);
@@ -565,6 +562,9 @@ fn check_legality_of_move_bindings(cx: &MatchVisitor,
                         }
                         _ => {}
                     }
+                } else {
+                    cx.tcx.sess.delay_span_bug(pat.span, "missing binding mode");
+                }
             }
             true
         });

src/librustc_typeck/check/regionck.rs

@@ -1039,12 +1039,14 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
                 match sub_pat.node {
                     // `ref x` pattern
                     PatKind::Binding(..) => {
-                        let bm = *mc.tables.pat_binding_modes().get(sub_pat.hir_id)
+                        if let Some(&bm) = mc.tables.pat_binding_modes().get(sub_pat.hir_id) {
-                                                               .expect("missing binding mode");
                             if let ty::BindByReference(mutbl) = bm {
                                 self.link_region_from_node_type(sub_pat.span, sub_pat.hir_id,
                                                                 mutbl, &sub_cmt);
                             }
+                        } else {
+                            self.tcx.sess.delay_span_bug(sub_pat.span, "missing binding mode");
+                        }
                     }
                     _ => {}
                 }