fallout from removing hir::ExprRange

[rust.git] / src / librustc_passes / consts.rs

diff --git a/src/librustc_passes/consts.rs b/src/librustc_passes/consts.rs
index 60cc658eeca8fb21e3cdf2f800da339d2b89cb81..f6e4f3191efc4ffceff1c7b366df70d5a3d040a7 100644 (file)
--- a/src/librustc_passes/consts.rs
+++ b/src/librustc_passes/consts.rs
@@ -41,7 +41,7 @@
 use rustc::middle::const_qualif::ConstQualif;
 use rustc::lint::builtin::CONST_ERR;
 
-use rustc_front::hir;
+use rustc_front::hir::{self, PatKind};
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::feature_gate::UnstableFeatures;
@@ -249,9 +249,9 @@ fn check_static_type(&self, e: &hir::Expr) {
         let ty = self.tcx.node_id_to_type(e.id);
         let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, None);
         let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic);
-        let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut();
-        fulfill_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause);
-        match fulfill_cx.select_all_or_error(&infcx) {
+        let mut fulfillment_cx = traits::FulfillmentContext::new();
+        fulfillment_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause);
+        match fulfillment_cx.select_all_or_error(&infcx) {
             Ok(()) => { },
             Err(ref errors) => {
                 traits::report_fulfillment_errors(&infcx, errors);
@@ -266,20 +266,20 @@ fn visit_item(&mut self, i: &hir::Item) {
         assert_eq!(self.mode, Mode::Var);
         match i.node {
             hir::ItemStatic(_, hir::MutImmutable, ref expr) => {
-                self.check_static_type(&**expr);
-                self.global_expr(Mode::Static, &**expr);
+                self.check_static_type(&expr);
+                self.global_expr(Mode::Static, &expr);
             }
             hir::ItemStatic(_, hir::MutMutable, ref expr) => {
-                self.check_static_mut_type(&**expr);
-                self.global_expr(Mode::StaticMut, &**expr);
+                self.check_static_mut_type(&expr);
+                self.global_expr(Mode::StaticMut, &expr);
             }
             hir::ItemConst(_, ref expr) => {
-                self.global_expr(Mode::Const, &**expr);
+                self.global_expr(Mode::Const, &expr);
             }
             hir::ItemEnum(ref enum_definition, _) => {
                 for var in &enum_definition.variants {
                     if let Some(ref ex) = var.node.disr_expr {
-                        self.global_expr(Mode::Const, &**ex);
+                        self.global_expr(Mode::Const, &ex);
                     }
                 }
             }
@@ -293,7 +293,7 @@ fn visit_trait_item(&mut self, t: &'v hir::TraitItem) {
         match t.node {
             hir::ConstTraitItem(_, ref default) => {
                 if let Some(ref expr) = *default {
-                    self.global_expr(Mode::Const, &*expr);
+                    self.global_expr(Mode::Const, &expr);
                 } else {
                     intravisit::walk_trait_item(self, t);
                 }
@@ -305,7 +305,7 @@ fn visit_trait_item(&mut self, t: &'v hir::TraitItem) {
     fn visit_impl_item(&mut self, i: &'v hir::ImplItem) {
         match i.node {
             hir::ImplItemKind::Const(_, ref expr) => {
-                self.global_expr(Mode::Const, &*expr);
+                self.global_expr(Mode::Const, &expr);
             }
             _ => self.with_mode(Mode::Var, |v| intravisit::walk_impl_item(v, i)),
         }
@@ -322,12 +322,12 @@ fn visit_fn(&mut self,
 
     fn visit_pat(&mut self, p: &hir::Pat) {
         match p.node {
-            hir::PatLit(ref lit) => {
-                self.global_expr(Mode::Const, &**lit);
+            PatKind::Lit(ref lit) => {
+                self.global_expr(Mode::Const, &lit);
             }
-            hir::PatRange(ref start, ref end) => {
-                self.global_expr(Mode::Const, &**start);
-                self.global_expr(Mode::Const, &**end);
+            PatKind::Range(ref start, ref end) => {
+                self.global_expr(Mode::Const, &start);
+                self.global_expr(Mode::Const, &end);
 
                 match const_eval::compare_lit_exprs(self.tcx, start, end) {
                     Some(Ordering::Less) |
@@ -379,17 +379,17 @@ fn visit_expr(&mut self, ex: &hir::Expr) {
         match ex.node {
             hir::ExprCall(ref callee, ref args) => {
                 for arg in args {
-                    self.visit_expr(&**arg)
+                    self.visit_expr(&arg)
                 }
 
                 let inner = self.qualif;
-                self.visit_expr(&**callee);
+                self.visit_expr(&callee);
                 // The callee's size doesn't count in the call.
                 let added = self.qualif - inner;
                 self.qualif = inner | (added - ConstQualif::NON_ZERO_SIZED);
             }
             hir::ExprRepeat(ref element, _) => {
-                self.visit_expr(&**element);
+                self.visit_expr(&element);
                 // The count is checked elsewhere (typeck).
                 let count = match node_ty.sty {
                     ty::TyArray(_, n) => n,
@@ -631,7 +631,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
             loop {
                 callee = match callee.node {
                     hir::ExprBlock(ref block) => match block.expr {
-                        Some(ref tail) => &**tail,
+                        Some(ref tail) => &tail,
                         None => break
                     },
                     _ => break
@@ -747,9 +747,6 @@ struct and enum constructors",
         hir::ExprAgain(_) |
         hir::ExprRet(_) |
 
-        // Miscellaneous expressions that could be implemented.
-        hir::ExprRange(..) |
-
         // Expressions with side-effects.
         hir::ExprAssign(..) |
         hir::ExprAssignOp(..) |
@@ -768,7 +765,8 @@ fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Exp
     match v.tcx.tables.borrow().adjustments.get(&e.id) {
         None |
         Some(&ty::adjustment::AdjustReifyFnPointer) |
-        Some(&ty::adjustment::AdjustUnsafeFnPointer) => {}
+        Some(&ty::adjustment::AdjustUnsafeFnPointer) |
+        Some(&ty::adjustment::AdjustMutToConstPointer) => {}
 
         Some(&ty::adjustment::AdjustDerefRef(
             ty::adjustment::AutoDerefRef { autoderefs, .. }