---

yaml
---
r: 98055
b: refs/heads/master
c: e64b49d
h: refs/heads/master
i:
  98053: ad6b0a5
  98051: e30578b
  98047: 00729a7
v: v3

Author: jhasse

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f42440bd7384bbd8febeea0220ce777d1d802ec9
+refs/heads/master: e64b49d8ff530e313927a9385e947188a08adddf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/src/librustc/middle/dead.rs

@@ -12,23 +12,20 @@
 // closely. The idea is that all reachable symbols are live, codes called
 // from live codes are live, and everything else is dead.
 
-use middle::lint::{allow, contains_lint, DeadCode};
-use middle::privacy;
 use middle::ty;
 use middle::typeck;
+use middle::privacy;
+use middle::lint::DeadCode;
 
 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::attr;
 use syntax::codemap;
 use syntax::parse::token;
 use syntax::visit::Visitor;
 use syntax::visit;
 
-pub static DEAD_CODE_LINT_STR: &'static str = "dead_code";
-
 // Any local node that may call something in its body block should be
 // explored. For example, if it's a live NodeItem that is a
 // function, then we should explore its block to check for codes that
@@ -199,57 +196,26 @@ impl Visitor<()> for MarkSymbolVisitor {
     }
 }
 
-fn has_allow_dead_code_or_lang_attr(attrs: &[ast::Attribute]) -> bool {
-    contains_lint(attrs, allow, DEAD_CODE_LINT_STR)
-    || attr::contains_name(attrs, "lang")
-}
-
-// This visitor seeds items that
-//   1) We want to explicitly consider as live:
-//     * Item annotated with #[allow(dead_code)]
-//         - This is done so that if we want to suppress warnings for a
-//           group of dead functions, we only have to annotate the "root".
-//           For example, if both `f` and `g` are dead and `f` calls `g`,
-//           then annotating `f` with `#[allow(dead_code)]` will suppress
-//           warning for both `f` and `g`.
-//     * Item annotated with #[lang=".."]
-//         - This is because lang items are always callable from elsewhere.
-//   or
-//   2) We are not sure to be live or not
-//     * Implementation of a trait method
-struct LifeSeeder {
+// 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 LifeSeeder {
+impl Visitor<()> for TraitMethodSeeder {
     fn visit_item(&mut self, item: &ast::Item, _: ()) {
-        if has_allow_dead_code_or_lang_attr(item.attrs) {
-            self.worklist.push(item.id);
-        }
         match item.node {
             ast::ItemImpl(_, Some(ref _trait_ref), _, ref methods) => {
                 for method in methods.iter() {
                     self.worklist.push(method.id);
                 }
             }
-            _ => ()
-        }
-        visit::walk_item(self, item, ());
-    }
-
-    fn visit_fn(&mut self, fk: &visit::FnKind,
-                _: &ast::FnDecl, block: &ast::Block,
-                _: codemap::Span, id: ast::NodeId, _: ()) {
-        // Check for method here because methods are not ast::Item
-        match *fk {
-            visit::FkMethod(_, _, method) => {
-                if has_allow_dead_code_or_lang_attr(method.attrs) {
-                    self.worklist.push(id);
-                }
+            ast::ItemMod(..) | ast::ItemFn(..) => {
+                visit::walk_item(self, item, ());
             }
             _ => ()
         }
-        visit::walk_block(self, block, ());
     }
 }
 
@@ -278,12 +244,12 @@ fn create_and_seed_worklist(tcx: ty::ctxt,
     }
 
     // Seed implemeneted trait methods
-    let mut life_seeder = LifeSeeder {
+    let mut trait_method_seeder = TraitMethodSeeder {
         worklist: worklist
     };
-    visit::walk_crate(&mut life_seeder, crate, ());
+    visit::walk_crate(&mut trait_method_seeder, crate, ());
 
-    return life_seeder.worklist;
+    return trait_method_seeder.worklist;
 }
 
 fn find_live(tcx: ty::ctxt,

trunk/src/librustc/middle/lint.rs

@@ -34,7 +34,6 @@
 //! Context itself, span_lint should be used instead of add_lint.
 
 use driver::session;
-use middle::dead::DEAD_CODE_LINT_STR;
 use middle::privacy;
 use middle::trans::adt; // for `adt::is_ffi_safe`
 use middle::ty;
@@ -294,7 +293,7 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: warn
     }),
 
-    (DEAD_CODE_LINT_STR,
+    ("dead_code",
      LintSpec {
         lint: DeadCode,
         desc: "detect piece of code that will never be used",
@@ -532,8 +531,6 @@ impl<'a> Context<'a> {
     }
 }
 
-// Check that every lint from the list of attributes satisfies `f`.
-// Return true if that's the case. Otherwise return false.
 pub fn each_lint(sess: session::Session,
                  attrs: &[ast::Attribute],
                  f: |@ast::MetaItem, level, @str| -> bool)
@@ -567,25 +564,6 @@ pub fn each_lint(sess: session::Session,
     true
 }
 
-// Check from a list of attributes if it contains the appropriate
-// `#[level(lintname)]` attribute (e.g. `#[allow(dead_code)]).
-pub fn contains_lint(attrs: &[ast::Attribute],
-                    level: level, lintname: &'static str) -> bool {
-    let level_name = level_to_str(level);
-    for attr in attrs.iter().filter(|m| level_name == m.name()) {
-        if attr.meta_item_list().is_none() {
-            continue
-        }
-        let list = attr.meta_item_list().unwrap();
-        for meta_item in list.iter() {
-            if lintname == meta_item.name() {
-                return true;
-            }
-        }
-    }
-    false
-}
-
 fn check_while_true_expr(cx: &Context, e: &ast::Expr) {
     match e.node {
         ast::ExprWhile(cond, _) => {

trunk/src/librustpkg/util.rs

@@ -185,10 +185,6 @@ pub fn compile_input(context: &BuildContext,
     let csysroot = context.sysroot();
     debug!("compile_input's sysroot = {}", csysroot.display());
 
-    let crate_type = match what {
-        Lib => session::OutputDylib,
-        Test | Bench | Main => session::OutputExecutable,
-    };
     let matches = getopts(debug_flags()
                           + match what {
                               Lib => ~[~"--lib"],
@@ -230,7 +226,6 @@ pub fn compile_input(context: &BuildContext,
     debug!("Output type = {:?}", output_type);
 
     let options = @session::options {
-        outputs: ~[crate_type],
         optimize: opt,
         test: what == Test || what == Bench,
         maybe_sysroot: Some(sysroot_to_use),

trunk/src/test/compile-fail/lint-dead-code-1.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[no_std];
 #[allow(unused_variable)];
 #[deny(dead_code)];
 
@@ -86,13 +85,3 @@ fn foo() { //~ ERROR: code is never used
 fn bar() { //~ ERROR: code is never used
     foo();
 }
-
-// Code with #[allow(dead_code)] should be marked live (and thus anything it
-// calls is marked live)
-#[allow(dead_code)]
-fn g() { h(); }
-fn h() {}
-
-// Similarly, lang items are live
-#[lang="fail_"]
-fn fail(_: *u8, _: *u8, _: uint) -> ! { loop {} }