---

yaml
---
r: 146687
b: refs/heads/try2
c: ec27c09
h: refs/heads/master
i:
  146685: 0de880f
  146683: a15b172
  146679: 1746a6b
  146671: 5998319
  146655: 8315cdc
  146623: e07f3e8
  146559: 2ed74a1
  146431: 6c432b2
v: v3

Author: TeXitoi

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 6c8b702cf7f7b67e3076091cdf12750551f3830c
+refs/heads/try2: ec27c09bdfa9fbdbf643b3f2f29146c1747e7297
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/middle/reachable.rs

@@ -260,132 +260,103 @@ impl ReachableContext {
                 continue
             }
             scanned.insert(search_item);
-            match self.tcx.items.find(&search_item) {
-                Some(item) => self.propagate_node(item, search_item,
-                                                  &mut visitor),
-                None if search_item == ast::CRATE_NODE_ID => {}
-                None => {
-                    self.tcx.sess.bug(format!("found unmapped ID in worklist: \
-                                               {}",
-                                              search_item))
-                }
-            }
-        }
-    }
+            self.reachable_symbols.insert(search_item);
 
-    fn propagate_node(&self, node: &ast_map::ast_node,
-                      search_item: ast::NodeId,
-                      visitor: &mut MarkSymbolVisitor) {
-        if !*self.tcx.sess.building_library {
-            // If we are building an executable, then there's no need to flag
-            // anything as external except for `extern fn` types. These
-            // functions may still participate in some form of native interface,
-            // but all other rust-only interfaces can be private (they will not
-            // participate in linkage after this product is produced)
-            match *node {
-                ast_map::node_item(item, _) => {
+            // Find the AST block corresponding to the item and visit it,
+            // marking all path expressions that resolve to something
+            // interesting.
+            match self.tcx.items.find(&search_item) {
+                Some(&ast_map::node_item(item, _)) => {
                     match item.node {
-                        ast::item_fn(_, ast::extern_fn, _, _, _) => {
-                            self.reachable_symbols.insert(search_item);
+                        ast::item_fn(_, _, _, _, ref search_block) => {
+                            if item_might_be_inlined(item) {
+                                visit::walk_block(&mut visitor, search_block, ())
+                            }
                         }
-                        _ => {}
-                    }
-                }
-                _ => {}
-            }
-        } else {
-            // If we are building a library, then reachable symbols will
-            // continue to participate in linkage after this product is
-            // produced. In this case, we traverse the ast node, recursing on
-            // all reachable nodes from this one.
-            self.reachable_symbols.insert(search_item);
-        }
 
-        match *node {
-            ast_map::node_item(item, _) => {
-                match item.node {
-                    ast::item_fn(_, _, _, _, ref search_block) => {
-                        if item_might_be_inlined(item) {
-                            visit::walk_block(visitor, search_block, ())
-                        }
-                    }
-
-                    // Implementations of exported structs/enums need to get
-                    // added to the worklist (as all their methods should be
-                    // accessible)
-                    ast::item_struct(*) | ast::item_enum(*) => {
-                        let def = local_def(item.id);
-                        let impls = match self.tcx.inherent_impls.find(&def) {
-                            Some(&impls) => impls,
-                            None => return
-                        };
-                        for imp in impls.iter() {
-                            if is_local(imp.did) {
-                                self.worklist.push(imp.did.node);
+                        // Implementations of exported structs/enums need to get
+                        // added to the worklist (as all their methods should be
+                        // accessible)
+                        ast::item_struct(*) | ast::item_enum(*) => {
+                            let def = local_def(item.id);
+                            let impls = match self.tcx.inherent_impls.find(&def) {
+                                Some(&impls) => impls,
+                                None => continue
+                            };
+                            for imp in impls.iter() {
+                                if is_local(imp.did) {
+                                    self.worklist.push(imp.did.node);
+                                }
                             }
                         }
-                    }
 
-                    // Propagate through this impl
-                    ast::item_impl(_, _, _, ref methods) => {
-                        for method in methods.iter() {
-                            self.worklist.push(method.id);
+                        // Propagate through this impl
+                        ast::item_impl(_, _, _, ref methods) => {
+                            for method in methods.iter() {
+                                self.worklist.push(method.id);
+                            }
                         }
-                    }
 
-                    // Default methods of exported traits need to all be
-                    // accessible.
-                    ast::item_trait(_, _, ref methods) => {
-                        for method in methods.iter() {
-                            match *method {
-                                ast::required(*) => {}
-                                ast::provided(ref method) => {
-                                    self.worklist.push(method.id);
+                        // Default methods of exported traits need to all be
+                        // accessible.
+                        ast::item_trait(_, _, ref methods) => {
+                            for method in methods.iter() {
+                                match *method {
+                                    ast::required(*) => {}
+                                    ast::provided(ref method) => {
+                                        self.worklist.push(method.id);
+                                    }
                                 }
                             }
                         }
-                    }
 
-                    // These are normal, nothing reachable about these
-                    // inherently and their children are already in the
-                    // worklist
-                    ast::item_static(*) | ast::item_ty(*) |
-                        ast::item_mod(*) | ast::item_foreign_mod(*) => {}
+                        // These are normal, nothing reachable about these
+                        // inherently and their children are already in the
+                        // worklist
+                        ast::item_static(*) | ast::item_ty(*) |
+                            ast::item_mod(*) | ast::item_foreign_mod(*) => {}
 
-                    _ => {
-                        self.tcx.sess.span_bug(item.span,
-                                               "found non-function item \
-                                                in worklist?!")
+                        _ => {
+                            self.tcx.sess.span_bug(item.span,
+                                                   "found non-function item \
+                                                    in worklist?!")
+                        }
                     }
                 }
-            }
-            ast_map::node_trait_method(trait_method, _, _) => {
-                match *trait_method {
-                    ast::required(*) => {
-                        // Keep going, nothing to get exported
+                Some(&ast_map::node_trait_method(trait_method, _, _)) => {
+                    match *trait_method {
+                        ast::required(*) => {
+                            // Keep going, nothing to get exported
+                        }
+                        ast::provided(ref method) => {
+                            visit::walk_block(&mut visitor, &method.body, ())
+                        }
                     }
-                    ast::provided(ref method) => {
-                        visit::walk_block(visitor, &method.body, ())
+                }
+                Some(&ast_map::node_method(method, did, _)) => {
+                    if method_might_be_inlined(self.tcx, method, did) {
+                        visit::walk_block(&mut visitor, &method.body, ())
                     }
                 }
-            }
-            ast_map::node_method(method, did, _) => {
-                if method_might_be_inlined(self.tcx, method, did) {
-                    visit::walk_block(visitor, &method.body, ())
+                // Nothing to recurse on for these
+                Some(&ast_map::node_foreign_item(*)) |
+                Some(&ast_map::node_variant(*)) |
+                Some(&ast_map::node_struct_ctor(*)) => {}
+                Some(_) => {
+                    let ident_interner = token::get_ident_interner();
+                    let desc = ast_map::node_id_to_str(self.tcx.items,
+                                                       search_item,
+                                                       ident_interner);
+                    self.tcx.sess.bug(format!("found unexpected thingy in \
+                                               worklist: {}",
+                                               desc))
+                }
+                None if search_item == ast::CRATE_NODE_ID => {}
+                None => {
+                    self.tcx.sess.bug(format!("found unmapped ID in worklist: \
+                                               {}",
+                                              search_item))
                 }
-            }
-            // Nothing to recurse on for these
-            ast_map::node_foreign_item(*) |
-            ast_map::node_variant(*) |
-            ast_map::node_struct_ctor(*) => {}
-            _ => {
-                let ident_interner = token::get_ident_interner();
-                let desc = ast_map::node_id_to_str(self.tcx.items,
-                                                   search_item,
-                                                   ident_interner);
-                self.tcx.sess.bug(format!("found unexpected thingy in \
-                                           worklist: {}",
-                                           desc))
             }
         }
     }

branches/try2/src/librustc/middle/trans/base.rs

@@ -2294,7 +2294,7 @@ fn finish_register_fn(ccx: @mut CrateContext, sp: Span, sym: ~str, node_id: ast:
                       llfn: ValueRef) {
     ccx.item_symbols.insert(node_id, sym);
 
-    if !ccx.reachable.contains(&node_id) {
+    if !*ccx.sess.building_library {
         lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
     }
 
@@ -2504,7 +2504,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                                     llvm::LLVMAddGlobal(ccx.llmod, llty, buf)
                                 };
 
-                                if !ccx.reachable.contains(&id) {
+                                if !*ccx.sess.building_library {
                                     lib::llvm::SetLinkage(g, lib::llvm::InternalLinkage);
                                 }