---

yaml
---
r: 232727
b: refs/heads/try
c: dec4351
h: refs/heads/master
i:
  232725: da38e5e
  232723: ddbe18a
  232719: c4f4eba
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: a48c29dcea0d0107c3e0bf761f97d65941a3d73d
+refs/heads/try: dec43510f1f8f053f86178b0710ec141f4644d20
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/libcore/any.rs

@@ -13,11 +13,12 @@
 //!
 //! `Any` itself can be used to get a `TypeId`, and has more features when used
 //! as a trait object. As `&Any` (a borrowed trait object), it has the `is` and
-//! `as_ref` methods, to test if the contained value is of a given type, and to
-//! get a reference to the inner value as a type. As `&mut Any`, there is also
-//! the `as_mut` method, for getting a mutable reference to the inner value.
-//! `Box<Any>` adds the `move` method, which will unwrap a `Box<T>` from the
-//! object.  See the extension traits (`*Ext`) for the full details.
+//! `downcast_ref` methods, to test if the contained value is of a given type,
+//! and to get a reference to the inner value as a type. As `&mut Any`, there
+//! is also the `downcast_mut` method, for getting a mutable reference to the
+//! inner value. `Box<Any>` adds the `move` method, which will unwrap a
+//! `Box<T>` from the object. See the extension traits (`*Ext`) for the full
+//! details.
 //!
 //! Note that &Any is limited to testing whether a value is of a specified
 //! concrete type, and cannot be used to test whether a type implements a trait.

branches/try/src/librustc/middle/entry.rs

@@ -11,19 +11,20 @@
 
 use ast_map;
 use session::{config, Session};
-use syntax;
-use syntax::ast::{NodeId, Item};
+use syntax::ast::{Name, NodeId, Item, ItemFn};
 use syntax::attr;
 use syntax::codemap::Span;
-use syntax::entry::EntryPointType;
+use syntax::parse::token;
 use syntax::visit;
 use syntax::visit::Visitor;
 
-struct EntryContext<'a> {
+struct EntryContext<'a, 'ast: 'a> {
     session: &'a Session,
 
-    // The current depth in the ast
-    depth: usize,
+    ast_map: &'a ast_map::Map<'ast>,
+
+    // The interned Name for "main".
+    main_name: Name,
 
     // The top-level function called 'main'
     main_fn: Option<(NodeId, Span)>,
@@ -39,11 +40,9 @@ struct EntryContext<'a> {
     non_main_fns: Vec<(NodeId, Span)> ,
 }
 
-impl<'a, 'v> Visitor<'v> for EntryContext<'a> {
+impl<'a, 'ast, 'v> Visitor<'v> for EntryContext<'a, 'ast> {
     fn visit_item(&mut self, item: &Item) {
-        self.depth += 1;
         find_item(item, self);
-        self.depth -= 1;
     }
 }
 
@@ -64,7 +63,8 @@ pub fn find_entry_point(session: &Session, ast_map: &ast_map::Map) {
 
     let mut ctxt = EntryContext {
         session: session,
-        depth: 0,
+        main_name: token::intern("main"),
+        ast_map: ast_map,
         main_fn: None,
         attr_main_fn: None,
         start_fn: None,
@@ -77,35 +77,44 @@ pub fn find_entry_point(session: &Session, ast_map: &ast_map::Map) {
 }
 
 fn find_item(item: &Item, ctxt: &mut EntryContext) {
-    match syntax::entry::entry_point_type(item, ctxt.depth) {
-        EntryPointType::MainNamed => {
-            if ctxt.main_fn.is_none() {
-                ctxt.main_fn = Some((item.id, item.span));
-            } else {
-                span_err!(ctxt.session, item.span, E0136,
-                          "multiple 'main' functions");
+    match item.node {
+        ItemFn(..) => {
+            if item.ident.name == ctxt.main_name {
+                 ctxt.ast_map.with_path(item.id, |path| {
+                        if path.count() == 1 {
+                            // This is a top-level function so can be 'main'
+                            if ctxt.main_fn.is_none() {
+                                ctxt.main_fn = Some((item.id, item.span));
+                            } else {
+                                span_err!(ctxt.session, item.span, E0136,
+                                          "multiple 'main' functions");
+                            }
+                        } else {
+                            // This isn't main
+                            ctxt.non_main_fns.push((item.id, item.span));
+                        }
+                });
             }
-        },
-        EntryPointType::OtherMain => {
-            ctxt.non_main_fns.push((item.id, item.span));
-        },
-        EntryPointType::MainAttr => {
-            if ctxt.attr_main_fn.is_none() {
-                ctxt.attr_main_fn = Some((item.id, item.span));
-            } else {
-                span_err!(ctxt.session, item.span, E0137,
-                          "multiple functions with a #[main] attribute");
+
+            if attr::contains_name(&item.attrs, "main") {
+                if ctxt.attr_main_fn.is_none() {
+                    ctxt.attr_main_fn = Some((item.id, item.span));
+                } else {
+                    span_err!(ctxt.session, item.span, E0137,
+                              "multiple functions with a #[main] attribute");
+                }
             }
-        },
-        EntryPointType::Start => {
-            if ctxt.start_fn.is_none() {
-                ctxt.start_fn = Some((item.id, item.span));
-            } else {
-                span_err!(ctxt.session, item.span, E0138,
-                          "multiple 'start' functions");
+
+            if attr::contains_name(&item.attrs, "start") {
+                if ctxt.start_fn.is_none() {
+                    ctxt.start_fn = Some((item.id, item.span));
+                } else {
+                    span_err!(ctxt.session, item.span, E0138,
+                              "multiple 'start' functions");
+                }
             }
-        },
-        EntryPointType::None => ()
+        }
+        _ => ()
     }
 
     visit::walk_item(ctxt, item);

branches/try/src/libstd/collections/mod.rs

@@ -25,9 +25,9 @@
 //!
 //! Rust's collections can be grouped into four major categories:
 //!
-//! * Sequences: `Vec`, `VecDeque`, `LinkedList`
-//! * Maps: `HashMap`, `BTreeMap`
-//! * Sets: `HashSet`, `BTreeSet`
+//! * Sequences: `Vec`, `VecDeque`, `LinkedList`, `BitVec`
+//! * Maps: `HashMap`, `BTreeMap`, `VecMap`
+//! * Sets: `HashSet`, `BTreeSet`, `BitSet`
 //! * Misc: `BinaryHeap`
 //!
 //! # When Should You Use Which Collection?
@@ -70,11 +70,22 @@
 //! * You want to be able to get all of the entries in order on-demand.
 //! * You want a sorted map.
 //!
+//! ### Use a `VecMap` when:
+//! * You want a `HashMap` but with known to be small `usize` keys.
+//! * You want a `BTreeMap`, but with known to be small `usize` keys.
+//!
 //! ### Use the `Set` variant of any of these `Map`s when:
 //! * You just want to remember which keys you've seen.
 //! * There is no meaningful value to associate with your keys.
 //! * You just want a set.
 //!
+//! ### Use a `BitVec` when:
+//! * You want to store an unbounded number of booleans in a small space.
+//! * You want a bit vector.
+//!
+//! ### Use a `BitSet` when:
+//! * You want a `BitVec`, but want `Set` properties
+//!
 //! ### Use a `BinaryHeap` when:
 //!
 //! * You want to store a bunch of elements, but only ever want to process the
@@ -112,20 +123,31 @@
 //! | Vec          | O(1)           | O(n-i)*         | O(n-i)         | O(m)*  | O(n-i)         |
 //! | VecDeque     | O(1)           | O(min(i, n-i))* | O(min(i, n-i)) | O(m)*  | O(min(i, n-i)) |
 //! | LinkedList   | O(min(i, n-i)) | O(min(i, n-i))  | O(min(i, n-i)) | O(1)   | O(min(i, n-i)) |
+//! | BitVec       | O(1)           | O(n-i)*         | O(n-i)         | O(m)*  | O(n-i)         |
 //!
 //! Note that where ties occur, Vec is generally going to be faster than VecDeque, and VecDeque
-//! is generally going to be faster than LinkedList.
+//! is generally going to be faster than LinkedList. BitVec is not a general purpose collection, and
+//! therefore cannot reasonably be compared.
 //!
 //! ## Maps
 //!
-//! For Sets, all operations have the cost of the equivalent Map operation.
+//! For Sets, all operations have the cost of the equivalent Map operation. For
+//! BitSet,
+//! refer to VecMap.
 //!
 //! |          | get       | insert   | remove   | predecessor |
 //! |----------|-----------|----------|----------|-------------|
 //! | HashMap  | O(1)~     | O(1)~*   | O(1)~    | N/A         |
 //! | BTreeMap | O(log n)  | O(log n) | O(log n) | O(log n)    |
+//! | VecMap   | O(1)      | O(1)?    | O(1)     | O(n)        |
+//!
+//! Note that VecMap is *incredibly* inefficient in terms of space. The O(1)
+//! insertion time assumes space for the element is already allocated.
+//! Otherwise, a large key may require a massive reallocation, with no direct
+//! relation to the number of elements in the collection.  VecMap should only be
+//! seriously considered for small keys.
 //!
-//! Note that BTreeMap's precise performance depends on the value of B.
+//! Note also that BTreeMap's precise performance depends on the value of B.
 //!
 //! # Correct and Efficient Usage of Collections
 //!

branches/try/src/libsyntax/entry.rs

@@ -90,7 +90,6 @@ pub mod attr;
 pub mod codemap;
 pub mod config;
 pub mod diagnostic;
-pub mod entry;
 pub mod feature_gate;
 pub mod fold;
 pub mod owned_slice;

branches/try/src/libsyntax/lib.rs

@@ -14,7 +14,6 @@
 #![allow(unused_imports)]
 use self::HasTestSignature::*;
 
-use std::iter;
 use std::slice;
 use std::mem;
 use std::vec;
@@ -25,7 +24,6 @@ use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute};
 use codemap;
 use diagnostic;
 use config;
-use entry::{self, EntryPointType};
 use ext::base::ExtCtxt;
 use ext::build::AstBuilder;
 use ext::expand::ExpansionConfig;
@@ -175,6 +173,28 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
         let tests = mem::replace(&mut self.tests, tests);
         let tested_submods = mem::replace(&mut self.tested_submods, tested_submods);
 
+        // Remove any #[main] from the AST so it doesn't clash with
+        // the one we're going to add. Only if compiling an executable.
+
+        mod_folded.items = mem::replace(&mut mod_folded.items, vec![]).move_map(|item| {
+            item.map(|ast::Item {id, ident, attrs, node, vis, span}| {
+                ast::Item {
+                    id: id,
+                    ident: ident,
+                    attrs: attrs.into_iter().filter_map(|attr| {
+                        if !attr.check_name("main") {
+                            Some(attr)
+                        } else {
+                            None
+                        }
+                    }).collect(),
+                    node: node,
+                    vis: vis,
+                    span: span
+                }
+            })
+        });
+
         if !tests.is_empty() || !tested_submods.is_empty() {
             let (it, sym) = mk_reexport_mod(&mut self.cx, tests, tested_submods);
             mod_folded.items.push(it);
@@ -191,55 +211,6 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
     }
 }
 
-struct EntryPointCleaner {
-    // Current depth in the ast
-    depth: usize,
-}
-
-impl fold::Folder for EntryPointCleaner {
-    fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> {
-        self.depth += 1;
-        let folded = fold::noop_fold_item(i, self).expect_one("noop did something");
-        self.depth -= 1;
-
-        // Remove any #[main] or #[start] from the AST so it doesn't
-        // clash with the one we're going to add, but mark it as
-        // #[allow(dead_code)] to avoid printing warnings.
-        let folded = match entry::entry_point_type(&*folded, self.depth) {
-            EntryPointType::MainNamed |
-            EntryPointType::MainAttr |
-            EntryPointType::Start =>
-                folded.map(|ast::Item {id, ident, attrs, node, vis, span}| {
-                    let allow_str = InternedString::new("allow");
-                    let dead_code_str = InternedString::new("dead_code");
-                    let allow_dead_code_item =
-                        attr::mk_list_item(allow_str,
-                                           vec![attr::mk_word_item(dead_code_str)]);
-                    let allow_dead_code = attr::mk_attr_outer(attr::mk_attr_id(),
-                                                              allow_dead_code_item);
-
-                    ast::Item {
-                        id: id,
-                        ident: ident,
-                        attrs: attrs.into_iter()
-                            .filter(|attr| {
-                                !attr.check_name("main") && !attr.check_name("start")
-                            })
-                            .chain(iter::once(allow_dead_code))
-                            .collect(),
-                        node: node,
-                        vis: vis,
-                        span: span
-                    }
-                }),
-            EntryPointType::None |
-            EntryPointType::OtherMain => folded,
-        };
-
-        SmallVector::one(folded)
-    }
-}
-
 fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
                    tested_submods: Vec<(ast::Ident, ast::Ident)>) -> (P<ast::Item>, ast::Ident) {
     let super_ = token::str_to_ident("super");
@@ -275,10 +246,6 @@ fn generate_test_harness(sess: &ParseSess,
                          krate: ast::Crate,
                          cfg: &ast::CrateConfig,
                          sd: &diagnostic::SpanHandler) -> ast::Crate {
-    // Remove the entry points
-    let mut cleaner = EntryPointCleaner { depth: 0 };
-    let krate = cleaner.fold_crate(krate);
-
     let mut feature_gated_cfgs = vec![];
     let mut cx: TestCtxt = TestCtxt {
         sess: sess,