---

yaml
---
r: 92401
b: refs/heads/auto
c: 1890290
h: refs/heads/master
i:
  92399: e530950
v: v3

Author: klutzy

[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: 6d2e61bc6cadcfde6952913b7e170ded57f7b0dd
+refs/heads/auto: 1890290ded2b56410b4b2e0dca4c1518b294a2b2
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -910,9 +910,11 @@ do
         # Try to have LLVM pull in as few dependencies as possible (#9397)
         LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
 
-        # pthreads works badly on mingw-w64 systems: #8996
+        # Use win32 native thread/lock apis instead of pthread wrapper.
+        # (llvm's configure tries to find pthread first, so we have to disable it explicitly.)
+        # Also note that pthreads works badly on mingw-w64 systems: #8996
         case "$CFG_BUILD" in
-            (*w64-mingw32)
+            (*-mingw32)
             LLVM_OPTS="$LLVM_OPTS --disable-pthreads"
             ;;
         esac

branches/auto/src/etc/mklldeps.py

@@ -53,6 +53,5 @@
         lib = lib[2:] # chop of the leading '-l'
         print "#[link(name = \"" + lib + "\", kind = \"static\")]"
     if os == 'win32':
-        print "#[link(name = \"pthread\")]"
         print "#[link(name = \"imagehlp\")]"
     print "extern {}"

branches/auto/src/etc/snapshot.py

@@ -32,8 +32,7 @@ def scrub(b):
     }
 
 winnt_runtime_deps = ["libgcc_s_dw2-1.dll",
-                      "libstdc++-6.dll",
-                      "libpthread-2.dll"]
+                      "libstdc++-6.dll"]
 
 def parse_line(n, line):
   global snapshotfile

branches/auto/src/etc/third-party/COPYING.LIB

@@ -6,9 +6,3 @@ Specifically:
      or (at your option) any later version.  See the files COPYING3 and COPYING.RUNTIME respectively.
      You can obtain a copy of the source of these libraries either here: http://sourceforge.net/projects/mingw/files/MinGW/Base/gcc/Version4/gcc-4.5.2-1/,
      or from the project website at http://gcc.gnu.org
-     
-   - libpthread-2.dll is distributed under the terms of the GNU Lesser General Public License 
-     as published by the Free Software Foundation; either version 2 of the License, or (at your option) 
-     any later version.  See the file COPYING.LIB for details.
-     You can obtain a copy of the source of this library either here: http://sourceforge.net/projects/mingw/files/MinGW/Base/pthreads-w32/pthreads-w32-2.8.0-3/,
-     or from the project website at http://sourceware.org/pthreads-win32

branches/auto/src/etc/third-party/README.txt

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

branches/auto/src/libextra/bitv.rs

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

branches/auto/src/libextra/btree.rs

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

branches/auto/src/libextra/sync.rs

@@ -670,6 +670,7 @@ 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"),
@@ -1295,6 +1296,8 @@ 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
 
@@ -1438,7 +1441,6 @@ 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/test.rs

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

branches/auto/src/libextra/treemap.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!("previous borrow of `{}` as mutable occurs here",
+                        format!("second 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!("previous borrow of `{}` occurs here",
+                        format!("second borrow of `{}` occurs here",
                              self.bccx.loan_path_to_str(new_loan.loan_path)));
                     return false;
                 }

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

@@ -47,6 +47,12 @@ 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/check_loop.rs

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

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

@@ -11,6 +11,7 @@
 
 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;
@@ -45,7 +46,10 @@ impl Visitor<()> for EntryContext {
 }
 
 pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map) {
-    if *session.building_library {
+
+    // FIXME #4404 android JNI hacks
+    if *session.building_library &&
+        session.targ_cfg.os != abi::OsAndroid {
         // No need to find a main function
         return;
     }
@@ -145,6 +149,10 @@ 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/entry.rs

@@ -1258,16 +1258,11 @@ 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,
-                                                            is_public,
+                                                            true,
                                                             sp);
 
                                 ModuleReducedGraphParent(

branches/auto/src/librustc/middle/resolve.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};
+use syntax::abi::{X86, X86_64, Arm, Mips, Rust, RustIntrinsic, OsWin32, OsAndroid};
 use syntax::visit;
 use syntax::visit::Visitor;
 
@@ -130,7 +130,7 @@ pub fn push_ctxt(s: &'static str) -> _InsnCtxt {
     _InsnCtxt { _x: () }
 }
 
-pub struct StatRecorder<'a> {
+struct StatRecorder<'a> {
     ccx: @mut CrateContext,
     name: &'a str,
     start: u64,
@@ -2289,7 +2289,11 @@ fn finish_register_fn(ccx: @mut CrateContext, sp: Span, sym: ~str, node_id: ast:
         lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
     }
 
-    if is_entry_fn(&ccx.sess, node_id) && !*ccx.sess.building_library {
+    // 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 {
         create_entry_wrapper(ccx, sp, llfn);
     }
 }
@@ -2357,7 +2361,13 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
         let llfty = Type::func([ccx.int_type, Type::i8().ptr_to().ptr_to()],
                                &ccx.int_type);
 
-        let llfn = decl_cdecl_fn(ccx.llmod, "main", llfty);
+        // 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 llbb = "top".with_c_str(|buf| {
             unsafe {
                 llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llfn, buf)
@@ -3189,13 +3199,14 @@ 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, 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 (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).
     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/base.rs

@@ -129,13 +129,11 @@ 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;
@@ -455,29 +453,12 @@ 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 {
-        // 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 }
+        // 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 }
     };
 
     declare_local(bcx,

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

@@ -24,7 +24,8 @@ pub trait DocFolder {
         let inner = inner;
         let c = |x| self.fold_item(x);
         let inner = match inner {
-            StructItem(mut i) => {
+            StructItem(i) => {
+                let mut i = 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)));
@@ -34,14 +35,15 @@ pub trait DocFolder {
             ModuleItem(i) => {
                 ModuleItem(self.fold_mod(i))
             },
-            EnumItem(mut i) => {
+            EnumItem(i) => {
+                let mut i = 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(mut i) => {
+            TraitItem(i) => {
                 fn vtrm<T: DocFolder>(this: &mut T, trm: TraitMethod) -> Option<TraitMethod> {
                     match trm {
                         Required(it) => {
@@ -58,19 +60,22 @@ 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(mut i) => {
+            ImplItem(i) => {
+                let mut i = 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(mut j) => {
+                    StructVariant(j) => {
+                        let mut j = 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/fold.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 && !e.variants_stripped {
+    if e.variants.len() == 0 {
         write!(w, " \\{\\}");
     } else {
         write!(w, " \\{\n");

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

@@ -303,7 +303,6 @@ 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]);