Add dead-code warning pass

Author: ktt3ja

src/etc/extract-tests.py

@@ -64,6 +64,7 @@
 #[ allow(dead_assignment) ];\n
 #[ allow(unused_mut) ];\n
 #[ allow(attribute_usage) ];\n
+#[ allow(dead_code) ];\n
 #[ feature(macro_rules, globs, struct_variant, managed_boxes) ];\n
 """ + block
             if xfail:

src/librustc/driver/driver.rs

@@ -310,6 +310,10 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         time(time_passes, "reachability checking", (), |_|
              reachable::find_reachable(ty_cx, method_map, &exported_items));
 
+    time(time_passes, "death checking", (), |_|
+         middle::dead::check_crate(ty_cx, method_map,
+                                   &exported_items, reachable_map, crate));
+
     time(time_passes, "lint checking", (), |_|
          lint::check_crate(ty_cx, &exported_items, crate));
 
@@ -510,19 +514,6 @@ pub fn pretty_print_input(sess: Session,
                           cfg: ast::CrateConfig,
                           input: &input,
                           ppm: PpMode) {
-    fn ann_typed_post(tcx: ty::ctxt, node: pprust::ann_node) {
-        match node {
-          pprust::node_expr(s, expr) => {
-            pp::space(s.s);
-            pp::word(s.s, "as");
-            pp::space(s.s);
-            pp::word(s.s, ppaux::ty_to_str(tcx, ty::expr_ty(tcx, expr)));
-            pprust::pclose(s);
-          }
-          _ => ()
-        }
-    }
-
     let crate = phase_1_parse_input(sess, cfg.clone(), input);
 
     let (crate, is_expanded) = match ppm {

src/librustc/lib.rs

@@ -77,6 +77,7 @@ pub mod middle {
     pub mod reachable;
     pub mod graph;
     pub mod cfg;
+    pub mod dead;
 }
 
 pub mod front {

src/librustc/middle/dead.rs

@@ -0,0 +1,352 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This implements the dead-code warning pass. It follows middle::reachable
+// closely. The idea is that all reachable symbols are live, codes called
+// from live codes are live, and everything else is dead.
+
+use middle::ty;
+use middle::typeck;
+use middle::privacy;
+use middle::lint::dead_code;
+
+use std::hashmap::HashSet;
+use syntax::ast;
+use syntax::ast_map;
+use syntax::ast_util::{local_def, def_id_of_def, is_local};
+use syntax::codemap;
+use syntax::parse::token;
+use syntax::visit::Visitor;
+use syntax::visit;
+
+// Any local node that may call something in its body block should be
+// explored. For example, if it's a live node_item that is a
+// function, then we should explore its block to check for codes that
+// may need to be marked as live.
+fn should_explore(tcx: ty::ctxt, def_id: ast::DefId) -> bool {
+    if !is_local(def_id) {
+        return false;
+    }
+    match tcx.items.find(&def_id.node) {
+        Some(&ast_map::node_item(..))
+        | Some(&ast_map::node_method(..))
+        | Some(&ast_map::node_trait_method(..)) => true,
+        _ => false
+    }
+}
+
+struct MarkSymbolVisitor {
+    worklist: ~[ast::NodeId],
+    method_map: typeck::method_map,
+    tcx: ty::ctxt,
+    live_symbols: ~HashSet<ast::NodeId>,
+}
+
+impl MarkSymbolVisitor {
+    fn new(tcx: ty::ctxt,
+           method_map: typeck::method_map,
+           worklist: ~[ast::NodeId]) -> MarkSymbolVisitor {
+        MarkSymbolVisitor {
+            worklist: worklist,
+            method_map: method_map,
+            tcx: tcx,
+            live_symbols: ~HashSet::new(),
+        }
+    }
+
+    fn lookup_and_handle_definition(&mut self, id: &ast::NodeId,
+                                    span: codemap::Span) {
+        let def = match self.tcx.def_map.find(id) {
+            Some(&def) => def,
+            None => self.tcx.sess.span_bug(span, "def ID not in def map?!"),
+        };
+        let def_id = match def {
+            ast::DefVariant(enum_id, _, _) => Some(enum_id),
+            ast::DefPrimTy(_) => None,
+            _ => Some(def_id_of_def(def)),
+        };
+        match def_id {
+            Some(def_id) => {
+                if should_explore(self.tcx, def_id) {
+                    self.worklist.push(def_id.node);
+                }
+                self.live_symbols.insert(def_id.node);
+            }
+            None => (),
+        }
+    }
+
+    fn mark_live_symbols(&mut self) {
+        let mut scanned = HashSet::new();
+        while self.worklist.len() > 0 {
+            let id = self.worklist.pop();
+            if scanned.contains(&id) {
+                continue
+            }
+            scanned.insert(id);
+            match self.tcx.items.find(&id) {
+                Some(node) => {
+                    self.live_symbols.insert(id);
+                    self.visit_node(node);
+                }
+                None => (),
+            }
+        }
+    }
+
+    fn visit_node(&mut self, node: &ast_map::ast_node) {
+        match *node {
+            ast_map::node_item(item, _) => {
+                match item.node {
+                    ast::item_fn(..)
+                    | ast::item_ty(..)
+                    | ast::item_static(..)
+                    | ast::item_foreign_mod(_) => {
+                        visit::walk_item(self, item, ());
+                    }
+                    _ => ()
+                }
+            }
+            ast_map::node_trait_method(trait_method, _, _) => {
+                visit::walk_trait_method(self, trait_method, ());
+            }
+            ast_map::node_method(method, _, _) => {
+                visit::walk_block(self, method.body, ());
+            }
+            _ => ()
+        }
+    }
+}
+
+impl Visitor<()> for MarkSymbolVisitor {
+
+    fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
+        match expr.node {
+            ast::ExprPath(_) | ast::ExprStruct(..) => {
+                self.lookup_and_handle_definition(&expr.id, expr.span);
+            }
+            ast::ExprMethodCall(..) => {
+                match self.method_map.find(&expr.id) {
+                    Some(&typeck::method_map_entry {
+                        origin: typeck::method_static(def_id),
+                        ..
+                    }) => {
+                        if should_explore(self.tcx, def_id) {
+                            self.worklist.push(def_id.node);
+                        }
+                        self.live_symbols.insert(def_id.node);
+                    }
+                    Some(_) => (),
+                    None => {
+                        self.tcx.sess.span_bug(expr.span,
+                                               "method call expression not \
+                                                in method map?!")
+                    }
+                }
+            }
+            _ => ()
+        }
+
+        visit::walk_expr(self, expr, ())
+    }
+
+    fn visit_ty(&mut self, typ: &ast::Ty, _: ()) {
+        match typ.node {
+            ast::ty_path(_, _, ref id) => {
+                self.lookup_and_handle_definition(id, typ.span);
+            }
+            _ => visit::walk_ty(self, typ, ()),
+        }
+    }
+
+    fn visit_item(&mut self, _item: @ast::item, _: ()) {
+        // Do not recurse into items. These items will be added to the
+        // worklist and recursed into manually if necessary.
+    }
+}
+
+// This visitor is used to mark the implemented methods of a trait. Since we
+// can not be sure if such methods are live or dead, we simply mark them
+// as live.
+struct TraitMethodSeeder {
+    worklist: ~[ast::NodeId],
+}
+
+impl Visitor<()> for TraitMethodSeeder {
+    fn visit_item(&mut self, item: @ast::item, _: ()) {
+        match item.node {
+            ast::item_impl(_, Some(ref _trait_ref), _, ref methods) => {
+                for method in methods.iter() {
+                    self.worklist.push(method.id);
+                }
+            }
+            ast::item_mod(..) | ast::item_fn(..) => {
+                visit::walk_item(self, item, ());
+            }
+            _ => ()
+        }
+    }
+}
+
+fn create_and_seed_worklist(tcx: ty::ctxt,
+                            exported_items: &privacy::ExportedItems,
+                            reachable_symbols: &HashSet<ast::NodeId>,
+                            crate: &ast::Crate) -> ~[ast::NodeId] {
+    let mut worklist = ~[];
+
+    // Preferably, we would only need to seed the worklist with reachable
+    // symbols. However, since the set of reachable symbols differs
+    // depending on whether a crate is built as bin or lib, and we want
+    // the warning to be consistent, we also seed the worklist with
+    // exported symbols.
+    for &id in exported_items.iter() {
+        worklist.push(id);
+    }
+    for &id in reachable_symbols.iter() {
+        worklist.push(id);
+    }
+
+    // Seed entry point
+    match *tcx.sess.entry_fn {
+        Some((id, _)) => worklist.push(id),
+        None => ()
+    }
+
+    // Seed implemeneted trait methods
+    let mut trait_method_seeder = TraitMethodSeeder {
+        worklist: worklist
+    };
+    visit::walk_crate(&mut trait_method_seeder, crate, ());
+
+    return trait_method_seeder.worklist;
+}
+
+fn find_live(tcx: ty::ctxt,
+             method_map: typeck::method_map,
+             exported_items: &privacy::ExportedItems,
+             reachable_symbols: &HashSet<ast::NodeId>,
+             crate: &ast::Crate)
+             -> ~HashSet<ast::NodeId> {
+    let worklist = create_and_seed_worklist(tcx, exported_items,
+                                            reachable_symbols, crate);
+    let mut symbol_visitor = MarkSymbolVisitor::new(tcx, method_map, worklist);
+    symbol_visitor.mark_live_symbols();
+    symbol_visitor.live_symbols
+}
+
+fn should_warn(item: @ast::item) -> bool {
+    match item.node {
+        ast::item_static(..)
+        | ast::item_fn(..)
+        | ast::item_enum(..)
+        | ast::item_struct(..) => true,
+        _ => false
+    }
+}
+
+fn get_struct_ctor_id(item: &ast::item) -> Option<ast::NodeId> {
+    match item.node {
+        ast::item_struct(struct_def, _) => struct_def.ctor_id,
+        _ => None
+    }
+}
+
+struct DeadVisitor {
+    tcx: ty::ctxt,
+    live_symbols: ~HashSet<ast::NodeId>,
+}
+
+impl DeadVisitor {
+    // id := node id of an item's definition.
+    // ctor_id := `Some` if the item is a struct_ctor (tuple struct),
+    //            `None` otherwise.
+    // If the item is a struct_ctor, then either its `id` or
+    // `ctor_id` (unwrapped) is in the live_symbols set. More specifically,
+    // DefMap maps the ExprPath of a struct_ctor to the node referred by
+    // `ctor_id`. On the other hand, in a statement like
+    // `type <ident> <generics> = <ty>;` where <ty> refers to a struct_ctor,
+    // DefMap maps <ty> to `id` instead.
+    fn symbol_is_live(&mut self, id: ast::NodeId,
+                      ctor_id: Option<ast::NodeId>) -> bool {
+        if self.live_symbols.contains(&id)
+           || ctor_id.map_default(false,
+                                  |ctor| self.live_symbols.contains(&ctor)) {
+            return true;
+        }
+        // If it's a type whose methods are live, then it's live, too.
+        // This is done to handle the case where, for example, the static
+        // method of a private type is used, but the type itself is never
+        // called directly.
+        let def_id = local_def(id);
+        match self.tcx.inherent_impls.find(&def_id) {
+            None => (),
+            Some(ref impl_list) => {
+                for impl_ in impl_list.iter() {
+                    for method in impl_.methods.iter() {
+                        if self.live_symbols.contains(&method.def_id.node) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        false
+    }
+}
+
+impl Visitor<()> for DeadVisitor {
+    fn visit_item(&mut self, item: @ast::item, _: ()) {
+        let ctor_id = get_struct_ctor_id(item);
+        if !self.symbol_is_live(item.id, ctor_id) && should_warn(item) {
+            self.tcx.sess.add_lint(dead_code, item.id, item.span,
+                                   format!("code is never used: `{}`",
+                                           token::ident_to_str(&item.ident)));
+        }
+        visit::walk_item(self, item, ());
+    }
+
+    fn visit_fn(&mut self, fk: &visit::fn_kind,
+                _: &ast::fn_decl, block: ast::P<ast::Block>,
+                span: codemap::Span, id: ast::NodeId, _: ()) {
+        // Have to warn method here because methods are not ast::item
+        match *fk {
+            visit::fk_method(..) => {
+                let ident = visit::name_of_fn(fk);
+                if !self.symbol_is_live(id, None) {
+                    self.tcx.sess
+                            .add_lint(dead_code, id, span,
+                                      format!("code is never used: `{}`",
+                                              token::ident_to_str(&ident)));
+                }
+            }
+            _ => ()
+        }
+        visit::walk_block(self, block, ());
+    }
+
+    // Overwrite so that we don't warn the trait method itself.
+    fn visit_trait_method(&mut self, trait_method :&ast::trait_method, _: ()) {
+        match *trait_method {
+            ast::provided(method) => visit::walk_block(self, method.body, ()),
+            ast::required(_) => ()
+        }
+    }
+}
+
+pub fn check_crate(tcx: ty::ctxt,
+                   method_map: typeck::method_map,
+                   exported_items: &privacy::ExportedItems,
+                   reachable_symbols: &HashSet<ast::NodeId>,
+                   crate: &ast::Crate) {
+    let live_symbols = find_live(tcx, method_map, exported_items,
+                                 reachable_symbols, crate);
+    let mut visitor = DeadVisitor { tcx: tcx, live_symbols: live_symbols };
+    visit::walk_crate(&mut visitor, crate, ());
+}