---

yaml
---
r: 92403
b: refs/heads/auto
c: c87b9d3
h: refs/heads/master
i:
  92401: 13f8413
  92399: e530950
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: b0a9937a6d252eaf6c936284c377227ae510cc0f
+refs/heads/auto: c87b9d37f7a72e8632af676c2bb579f8967d9cd8
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/libextra/bitv.rs

@@ -932,7 +932,8 @@ impl<'a> Iterator<uint> for BitvSetIterator<'a> {
 mod tests {
     use extra::test::BenchHarness;
 
-    use bitv::*;
+    use bitv::{Bitv, SmallBitv, BigBitv, BitvSet, from_bools, from_fn,
+               from_bytes};
     use bitv;
 
     use std::uint;

branches/auto/src/libextra/btree.rs

@@ -407,7 +407,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> {
 #[cfg(test)]
 mod test_btree{
 
-    use super::*;
+    use super::{BTree, LeafElt};
 
     ///Tests the functionality of the add methods (which are unfinished).
     #[test]

branches/auto/src/libextra/sync.rs

@@ -329,7 +329,7 @@ impl Sem<~[WaitQueue]> {
  ****************************************************************************/
 
 /// A counting, blocking, bounded-waiting semaphore.
-struct Semaphore { priv sem: Sem<()> }
+pub struct Semaphore { priv sem: Sem<()> }
 
 
 impl Clone for Semaphore {

branches/auto/src/libextra/test.rs

@@ -670,7 +670,6 @@ fn should_sort_failures_before_printing_them() {
     use std::io::Decorator;
     use std::io::mem::MemWriter;
     use std::str;
-    fn dummy() {}
 
     let test_a = TestDesc {
         name: StaticTestName("a"),
@@ -1296,8 +1295,6 @@ mod tests {
 
     #[test]
     pub fn filter_for_ignored_option() {
-        fn dummy() {}
-
         // When we run ignored tests the test filter should filter out all the
         // unignored tests and flip the ignore flag on the rest to false
 
@@ -1441,6 +1438,7 @@ mod tests {
         assert_eq!(diff2.len(), 7);
     }
 
+    #[test]
     pub fn ratchet_test() {
 
         let dpth = TempDir::new("test-ratchet").expect("missing test for ratchet");

branches/auto/src/libextra/treemap.rs

@@ -884,7 +884,7 @@ impl<T: TotalOrd> Extendable<T> for TreeSet<T> {
 #[cfg(test)]
 mod test_treemap {
 
-    use super::*;
+    use super::{TreeMap, TreeNode};
 
     use std::rand::Rng;
     use std::rand;

branches/auto/src/librustc/middle/borrowck/check_loans.rs

@@ -238,7 +238,7 @@ impl<'a> CheckLoanCtxt<'a> {
                              self.bccx.loan_path_to_str(new_loan.loan_path)));
                     self.bccx.span_note(
                         old_loan.span,
-                        format!("second borrow of `{}` as mutable occurs here",
+                        format!("previous borrow of `{}` as mutable occurs here",
                              self.bccx.loan_path_to_str(new_loan.loan_path)));
                     return false;
                 }
@@ -253,7 +253,7 @@ impl<'a> CheckLoanCtxt<'a> {
                              self.bccx.mut_to_str(old_loan.mutbl)));
                     self.bccx.span_note(
                         old_loan.span,
-                        format!("second borrow of `{}` occurs here",
+                        format!("previous borrow of `{}` occurs here",
                              self.bccx.loan_path_to_str(new_loan.loan_path)));
                     return false;
                 }

branches/auto/src/librustc/middle/check_loop.rs

@@ -47,12 +47,6 @@ impl Visitor<Context> for CheckLoopVisitor {
             }
             ast::ExprBreak(_) => self.require_loop("break", cx, e.span),
             ast::ExprAgain(_) => self.require_loop("continue", cx, e.span),
-            ast::ExprRet(oe) => {
-                if cx == Closure {
-                    self.tcx.sess.span_err(e.span, "`return` in a closure");
-                }
-                visit::walk_expr_opt(self, oe, cx);
-            }
             _ => visit::walk_expr(self, e, cx)
         }
     }

branches/auto/src/librustc/middle/dead.rs

@@ -158,17 +158,9 @@ impl Visitor<()> for MarkSymbolVisitor {
         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);
-            }
-            _ => visit::walk_ty(self, typ, ()),
-        }
-    }
-
-    fn visit_path(&mut self, _: &ast::Path, id: ast::NodeId, _: ()) {
+    fn visit_path(&mut self, path: &ast::Path, id: ast::NodeId, _: ()) {
         self.lookup_and_handle_definition(&id);
+        visit::walk_path(self, path, ());
     }
 
     fn visit_item(&mut self, _item: @ast::item, _: ()) {

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

@@ -11,7 +11,6 @@
 
 use driver::session;
 use driver::session::Session;
-use syntax::abi;
 use syntax::ast::{Crate, NodeId, item, item_fn};
 use syntax::ast_map;
 use syntax::attr;
@@ -46,10 +45,7 @@ impl Visitor<()> for EntryContext {
 }
 
 pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map) {
-
-    // FIXME #4404 android JNI hacks
-    if *session.building_library &&
-        session.targ_cfg.os != abi::OsAndroid {
+    if *session.building_library {
         // No need to find a main function
         return;
     }
@@ -149,10 +145,6 @@ fn configure_main(this: &mut EntryContext) {
                 }
             }
             this.session.abort_if_errors();
-        } else {
-            // If we *are* building a library, then we're on android where we still might
-            // optionally want to translate main $4404
-            assert_eq!(this.session.targ_cfg.os, abi::OsAndroid);
         }
     }
 }

branches/auto/src/librustc/middle/resolve.rs

@@ -1258,11 +1258,16 @@ impl Resolver {
                                 let parent_link =
                                     self.get_parent_link(new_parent, ident);
                                 let def_id = local_def(item.id);
+                                let ns = TypeNS;
+                                let is_public =
+                                    !name_bindings.defined_in_namespace(ns) ||
+                                     name_bindings.defined_in_public_namespace(ns);
+
                                 name_bindings.define_module(parent_link,
                                                             Some(def_id),
                                                             ImplModuleKind,
                                                             false,
-                                                            true,
+                                                            is_public,
                                                             sp);
 
                                 ModuleReducedGraphParent(

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

@@ -84,7 +84,7 @@ use syntax::parse::token::{special_idents};
 use syntax::print::pprust::stmt_to_str;
 use syntax::{ast, ast_util, codemap, ast_map};
 use syntax::attr::AttrMetaMethods;
-use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic, OsWin32, OsAndroid};
+use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic, OsWin32};
 use syntax::visit;
 use syntax::visit::Visitor;
 
@@ -130,7 +130,7 @@ pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
     _InsnCtxt { _x: () }
 }
 
-struct StatRecorder<'a> {
+pub struct StatRecorder<'a> {
     ccx: @mut CrateContext,
     name: &'a str,
     start: u64,
@@ -2289,11 +2289,7 @@ fn finish_register_fn(ccx: @mut CrateContext, sp: Span, sym: ~str, node_id: ast:
         lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
     }
 
-    // FIXME #4404 android JNI hacks
-    let is_entry = is_entry_fn(&ccx.sess, node_id) && (!*ccx.sess.building_library ||
-                      (*ccx.sess.building_library &&
-                       ccx.sess.targ_cfg.os == OsAndroid));
-    if is_entry {
+    if is_entry_fn(&ccx.sess, node_id) && !*ccx.sess.building_library {
         create_entry_wrapper(ccx, sp, llfn);
     }
 }
@@ -2361,13 +2357,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
         let llfty = Type::func([ccx.int_type, Type::i8().ptr_to().ptr_to()],
                                &ccx.int_type);
 
-        // FIXME #4404 android JNI hacks
-        let main_name = if *ccx.sess.building_library {
-            "amain"
-        } else {
-            "main"
-        };
-        let llfn = decl_cdecl_fn(ccx.llmod, main_name, llfty);
+        let llfn = decl_cdecl_fn(ccx.llmod, "main", llfty);
         let llbb = "top".with_c_str(|buf| {
             unsafe {
                 llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llfn, buf)
@@ -3199,14 +3189,13 @@ pub fn trans_crate(sess: session::Session,
     }).to_owned_vec();
 
     // Make sure that some other crucial symbols are not eliminated from the
-    // module. This includes the main function (main/amain elsewhere), the crate
-    // map (used for debug log settings and I/O), and finally the curious
-    // rust_stack_exhausted symbol. This symbol is required for use by the
-    // libmorestack library that we link in, so we must ensure that this symbol
-    // is not internalized (if defined in the crate).
+    // module. This includes the main function, the crate map (used for debug
+    // log settings and I/O), and finally the curious rust_stack_exhausted
+    // symbol. This symbol is required for use by the libmorestack library that
+    // we link in, so we must ensure that this symbol is not internalized (if
+    // defined in the crate).
     reachable.push(ccx.crate_map_name.to_owned());
     reachable.push(~"main");
-    reachable.push(~"amain");
     reachable.push(~"rust_stack_exhausted");
 
     return CrateTranslation {

branches/auto/src/librustc/middle/trans/debuginfo.rs

@@ -129,11 +129,13 @@ use driver::session;
 use lib::llvm::llvm;
 use lib::llvm::{ModuleRef, ContextRef, ValueRef};
 use lib::llvm::debuginfo::*;
+use middle::trans::adt;
+use middle::trans::base;
+use middle::trans::build;
 use middle::trans::common::*;
 use middle::trans::machine;
 use middle::trans::type_of;
 use middle::trans::type_::Type;
-use middle::trans::adt;
 use middle::trans;
 use middle::ty;
 use middle::pat_util;
@@ -453,12 +455,29 @@ pub fn create_self_argument_metadata(bcx: @mut Block,
 
     let address_operations = &[unsafe { llvm::LLVMDIBuilderCreateOpDeref(Type::i64().to_ref()) }];
 
+    // The self argument comes in one of two forms:
+    // (1) For `&self`, `~self`, and `@self` it is an alloca containing a pointer to the data. That
+    //     is the `{&~@}self` pointer is contained by value in the alloca, and `type_of_self` will
+    //     be `{&~@}Self`
+    // (2) For by-value `self`, `llptr` will not be an alloca, but a pointer to the self-value. That
+    //     is by-value `self` is always implicitly passed by reference (sic!). So we have a couple
+    //     of problems here:
+    //     (a) There is no alloca to give to `llvm.dbg.declare` and
+    //     (b) `type_of_self` is `Self`, but `llptr` is of type `*Self`
+    //     In order to solve this problem, the else branch below creates a helper alloca which
+    //     contains a copy of `llptr`. We then describe the `self` parameter by pointing
+    //     `llvm.dbg.declare` to this helper alloca and tell it that the pointer there needs to be
+    //     dereferenced once to get to the actual data (similar to non-immediate by-value args).
     let variable_access = if unsafe { llvm::LLVMIsAAllocaInst(llptr) } != ptr::null() {
         DirectVariable { alloca: llptr }
     } else {
-        // This is not stable and may break with future LLVM versions. llptr should really always
-        // be an alloca. Anything else is not supported and just works by chance.
-        IndirectVariable { alloca: llptr, address_operations: address_operations }
+        // Create a helper alloca that allows us to track the self-argument properly. The alloca
+        // contains a pointer to the self-value.
+        let ptr_type = ty::mk_mut_ptr(bcx.tcx(), type_of_self);
+        let helper_alloca = base::alloc_ty(bcx, ptr_type, "__self");
+        build::Store(bcx, llptr, helper_alloca);
+
+        IndirectVariable { alloca: helper_alloca, address_operations: address_operations }
     };
 
     declare_local(bcx,

branches/auto/src/librustdoc/fold.rs

@@ -24,8 +24,7 @@ pub trait DocFolder {
         let inner = inner;
         let c = |x| self.fold_item(x);
         let inner = match inner {
-            StructItem(i) => {
-                let mut i = i;
+            StructItem(mut i) => {
                 let mut foo = ~[]; swap(&mut foo, &mut i.fields);
                 let num_fields = foo.len();
                 i.fields.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
@@ -35,15 +34,14 @@ pub trait DocFolder {
             ModuleItem(i) => {
                 ModuleItem(self.fold_mod(i))
             },
-            EnumItem(i) => {
-                let mut i = i;
+            EnumItem(mut i) => {
                 let mut foo = ~[]; swap(&mut foo, &mut i.variants);
                 let num_variants = foo.len();
                 i.variants.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
                 i.variants_stripped |= num_variants != i.variants.len();
                 EnumItem(i)
             },
-            TraitItem(i) => {
+            TraitItem(mut i) => {
                 fn vtrm<T: DocFolder>(this: &mut T, trm: TraitMethod) -> Option<TraitMethod> {
                     match trm {
                         Required(it) => {
@@ -60,22 +58,19 @@ pub trait DocFolder {
                         },
                     }
                 }
-                let mut i = i;
                 let mut foo = ~[]; swap(&mut foo, &mut i.methods);
                 i.methods.extend(&mut foo.move_iter().filter_map(|x| vtrm(self, x)));
                 TraitItem(i)
             },
-            ImplItem(i) => {
-                let mut i = i;
+            ImplItem(mut i) => {
                 let mut foo = ~[]; swap(&mut foo, &mut i.methods);
                 i.methods.extend(&mut foo.move_iter().filter_map(|x| self.fold_item(x)));
                 ImplItem(i)
             },
             VariantItem(i) => {
                 let i2 = i.clone(); // this clone is small
                 match i.kind {
-                    StructVariant(j) => {
-                        let mut j = j;
+                    StructVariant(mut j) => {
                         let mut foo = ~[]; swap(&mut foo, &mut j.fields);
                         let num_fields = foo.len();
                         j.fields.extend(&mut foo.move_iter().filter_map(c));

branches/auto/src/librustdoc/html/render.rs

@@ -1202,7 +1202,7 @@ fn item_enum(w: &mut Writer, it: &clean::Item, e: &clean::Enum) {
            VisSpace(it.visibility),
            it.name.get_ref().as_slice(),
            e.generics);
-    if e.variants.len() == 0 {
+    if e.variants.len() == 0 && !e.variants_stripped {
         write!(w, " \\{\\}");
     } else {
         write!(w, " \\{\n");

branches/auto/src/libstd/hash.rs

@@ -303,6 +303,7 @@ impl Streaming for SipState {
 mod tests {
     use super::*;
     use prelude::*;
+    use super::SipState;
 
     // Hash just the bytes of the slice, without length prefix
     struct Bytes<'a>(&'a [u8]);

branches/auto/src/libstd/rt/mpmc_bounded_queue.rs

@@ -51,7 +51,7 @@ struct State<T> {
     pad3: [u8, ..64],
 }
 
-struct Queue<T> {
+pub struct Queue<T> {
     priv state: UnsafeArc<State<T>>,
 }
 

branches/auto/src/libsyntax/parse/obsolete.rs

@@ -44,6 +44,7 @@ pub enum ObsoleteSyntax {
     ObsoleteVecDotDotWildcard,
     ObsoleteBoxedClosure,
     ObsoleteClosureType,
+    ObsoleteMultipleImport,
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -140,6 +141,10 @@ impl ParserObsoleteMethods for Parser {
                 "closures are now written `|A| -> B` rather than `&fn(A) -> \
                  B`."
             ),
+            ObsoleteMultipleImport => (
+                "multiple imports",
+                "only one import is allowed per `use` statement"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);

branches/auto/src/libsyntax/parse/parser.rs

@@ -4968,6 +4968,7 @@ impl Parser {
         let mut vp = ~[self.parse_view_path()];
         while *self.token == token::COMMA {
             self.bump();
+            self.obsolete(*self.last_span, ObsoleteMultipleImport);
             vp.push(self.parse_view_path());
         }
         return vp;