rustc: check_const: cleanup/simplify the code.

Author: eddyb

src/librustc/middle/check_const.rs

@@ -14,8 +14,7 @@ use middle::ty;
 use util::ppaux;
 
 use syntax::ast;
-use syntax::visit::Visitor;
-use syntax::visit;
+use syntax::visit::{mod, Visitor};
 
 struct CheckCrateVisitor<'a, 'tcx: 'a> {
     tcx: &'a ty::ctxt<'tcx>,
@@ -36,24 +35,39 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
     {
         self.with_const(true, f);
     }
-    fn outside_const<F>(&mut self, f: F) where
-        F: FnOnce(&mut CheckCrateVisitor<'a, 'tcx>),
-    {
-        self.with_const(false, f);
-    }
 }
 
 impl<'a, 'tcx, 'v> Visitor<'v> for CheckCrateVisitor<'a, 'tcx> {
     fn visit_item(&mut self, i: &ast::Item) {
-        check_item(self, i);
+        match i.node {
+            ast::ItemStatic(_, _, ref ex) |
+            ast::ItemConst(_, ref ex) => {
+                self.inside_const(|v| v.visit_expr(&**ex));
+            }
+            ast::ItemEnum(ref enum_definition, _) => {
+                self.inside_const(|v| {
+                    for var in enum_definition.variants.iter() {
+                        if let Some(ref ex) = var.node.disr_expr {
+                            v.visit_expr(&**ex);
+                        }
+                    }
+                });
+            }
+            _ => self.with_const(false, |v| visit::walk_item(v, i))
+        }
     }
     fn visit_pat(&mut self, p: &ast::Pat) {
-        check_pat(self, p);
+        let is_const = match p.node {
+            ast::PatLit(_) | ast::PatRange(..) => true,
+            _ => false
+        };
+        self.with_const(is_const, |v| visit::walk_pat(v, p))
     }
     fn visit_expr(&mut self, ex: &ast::Expr) {
-        if check_expr(self, ex) {
-            visit::walk_expr(self, ex);
+        if self.in_const {
+            check_expr(self, ex);
         }
+        visit::walk_expr(self, ex);
     }
 }
 
@@ -63,40 +77,12 @@ pub fn check_crate(tcx: &ty::ctxt) {
     tcx.sess.abort_if_errors();
 }
 
-fn check_item(v: &mut CheckCrateVisitor, it: &ast::Item) {
-    match it.node {
-        ast::ItemStatic(_, _, ref ex) |
-        ast::ItemConst(_, ref ex) => {
-            v.inside_const(|v| v.visit_expr(&**ex));
-        }
-        ast::ItemEnum(ref enum_definition, _) => {
-            for var in (*enum_definition).variants.iter() {
-                for ex in var.node.disr_expr.iter() {
-                    v.inside_const(|v| v.visit_expr(&**ex));
-                }
-            }
-        }
-        _ => v.outside_const(|v| visit::walk_item(v, it))
-    }
-}
-
-fn check_pat(v: &mut CheckCrateVisitor, p: &ast::Pat) {
-    let is_const = match p.node {
-        ast::PatLit(_) | ast::PatRange(..) => true,
-        _ => false
-    };
-    v.with_const(is_const, |v| visit::walk_pat(v, p))
-}
-
-fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
-    if !v.in_const { return true }
-
+fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) {
     match e.node {
         ast::ExprUnary(ast::UnDeref, _) => {}
         ast::ExprUnary(ast::UnUniq, _) => {
             span_err!(v.tcx.sess, e.span, E0010,
                       "cannot do allocations in constant expressions");
-            return false;
         }
         ast::ExprBinary(..) | ast::ExprUnary(..) => {
             let method_call = ty::MethodCall::expr(e.id);
@@ -135,29 +121,22 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
                           "paths in constants may only refer to items without \
                            type parameters");
             }
-            match v.tcx.def_map.borrow().get(&e.id) {
-                Some(&DefStatic(..)) |
-                Some(&DefConst(..)) |
-                Some(&DefFn(..)) |
-                Some(&DefVariant(_, _, _)) |
-                Some(&DefStruct(_)) => { }
+            match v.tcx.def_map.borrow()[e.id] {
+                DefStatic(..) | DefConst(..) |
+                DefFn(..) | DefStruct(_) |
+                DefVariant(_, _, _) => {}
 
-                Some(&def) => {
+                def => {
                     debug!("(checking const) found bad def: {}", def);
                     span_err!(v.tcx.sess, e.span, E0014,
                               "paths in constants may only refer to constants \
                                or functions");
                 }
-                None => {
-                    v.tcx.sess.span_bug(e.span, "unbound path in const?!");
-                }
             }
         }
         ast::ExprCall(ref callee, _) => {
-            match v.tcx.def_map.borrow().get(&callee.id) {
-                Some(&DefStruct(..)) |
-                Some(&DefVariant(..)) => {}    // OK.
-
+            match v.tcx.def_map.borrow()[callee.id] {
+                DefStruct(..) | DefVariant(..) => {}    // OK.
                 _ => {
                     span_err!(v.tcx.sess, e.span, E0015,
                               "function calls in constants are limited to \
@@ -173,9 +152,9 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
                               "blocks in constants are limited to items and \
                                tail expressions");
                 match stmt.node {
-                    ast::StmtDecl(ref span, _) => {
-                        match span.node {
-                            ast::DeclLocal(_) => block_span_err(span.span),
+                    ast::StmtDecl(ref decl, _) => {
+                        match decl.node {
+                            ast::DeclLocal(_) => block_span_err(decl.span),
 
                             // Item statements are allowed
                             ast::DeclItem(_) => {}
@@ -189,9 +168,8 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
                     }
                 }
             }
-            match block.expr {
-                Some(ref expr) => { check_expr(v, &**expr); }
-                None => {}
+            if let Some(ref expr) = block.expr {
+                check_expr(v, &**expr);
             }
         }
         ast::ExprVec(_) |
@@ -215,11 +193,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &ast::Expr) -> bool {
             }
         }
 
-        _ => {
-            span_err!(v.tcx.sess, e.span, E0019,
-                      "constant contains unimplemented expression type");
-            return false;
-        }
+        _ => span_err!(v.tcx.sess, e.span, E0019,
+                       "constant contains unimplemented expression type")
     }
-    true
 }