---

yaml
---
r: 65914
b: refs/heads/master
c: 1854256
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1104e659d539faf40773cd6dc01015c00df498cd
+refs/heads/master: 18542568a8f7d5580094634c4a10695fb71ba74a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/RELEASES.txt

@@ -4,7 +4,7 @@ Version 0.7 (July 2013)
    * ??? changes, numerous bugfixes
 
    * Syntax changes
-      * `#[deriving(Encodable)]`, `#[deriving(Decodable)]`
+      * `#[deriving(Encodable)]`, `#[deriving(Decodable)]`      
 
    * Semantic changes
       * The `self` parameter no longer implicitly means `&'self self`,

trunk/src/etc/adb_run_wrapper.sh

@@ -2,7 +2,7 @@
 # usage : adb_run_wrapper [test dir - where test executables exist] [test executable]
 #
 
-# Sometimes android shell produce exitcode "1 : Text File Busy"
+# Sometimes android shell produce exitcode "1 : Text File Busy" 
 # Retry after $WAIT seconds, expecting resource cleaned-up
 WAIT=10
 PATH=$1
@@ -20,15 +20,15 @@ then
         while [ $L_RET -eq 1 ]
         do
             LD_LIBRARY_PATH=$PATH $PATH/$RUN $@ 1>$PATH/$RUN.stdout 2>$PATH/$RUN.stderr
-            L_RET=$?
+            L_RET=$? 
             if [ $L_COUNT -gt 0 ]
             then
                /system/bin/sleep $WAIT
                /system/bin/sync
             fi
             L_COUNT=`expr $L_COUNT+1`
         done
-
+        
         echo $L_RET > $PATH/$RUN.exitcode
 
     fi

trunk/src/librustc/middle/borrowck/gather_loans/gather_moves.rs

@@ -161,3 +161,4 @@ fn check_is_legal_to_move_from(bccx: @BorrowckCtxt,
         }
     }
 }
+

trunk/src/librustc/middle/effect.rs

@@ -154,3 +154,4 @@ pub fn check_crate(tcx: ty::ctxt,
 
     visit::visit_crate(crate, ((), visitor))
 }
+

trunk/src/librustc/middle/trans/base.rs

@@ -3094,7 +3094,6 @@ pub fn trans_crate(sess: session::Session,
               const_globals: @mut HashMap::new(),
               const_values: @mut HashMap::new(),
               extern_const_values: @mut HashMap::new(),
-              impl_method_cache: @mut HashMap::new(),
               module_data: @mut HashMap::new(),
               lltypes: @mut HashMap::new(),
               llsizingtypes: @mut HashMap::new(),

trunk/src/librustc/middle/trans/common.rs

@@ -205,8 +205,6 @@ pub struct CrateContext {
      // Cache of external const values
      extern_const_values: @mut HashMap<ast::def_id, ValueRef>,
 
-     impl_method_cache: @mut HashMap<(ast::def_id, ast::ident), ast::def_id>,
-
      module_data: @mut HashMap<~str, ValueRef>,
      lltypes: @mut HashMap<ty::t, TypeRef>,
      llsizingtypes: @mut HashMap<ty::t, TypeRef>,

trunk/src/librustc/middle/trans/meth.rs

@@ -381,37 +381,35 @@ pub fn method_from_methods(ms: &[@ast::method], name: ast::ident)
 pub fn method_with_name_or_default(ccx: @CrateContext,
                                    impl_id: ast::def_id,
                                    name: ast::ident) -> ast::def_id {
-    *do ccx.impl_method_cache.find_or_insert_with((impl_id, name)) |_| {
-        if impl_id.crate == ast::local_crate {
-            match ccx.tcx.items.get_copy(&impl_id.node) {
-                ast_map::node_item(@ast::item {
-                                   node: ast::item_impl(_, _, _, ref ms), _
-                                   }, _) => {
-                    let did = method_from_methods(*ms, name);
-                    if did.is_some() {
-                        did.get()
-                    } else {
-                        // Look for a default method
-                        let pmm = ccx.tcx.provided_methods;
-                        match pmm.find(&impl_id) {
-                            Some(pmis) => {
-                                for pmis.each |pmi| {
-                                    if pmi.method_info.ident == name {
-                                        debug!("pmi.method_info.did = %?", pmi.method_info.did);
-                                        return pmi.method_info.did;
-                                    }
-                                }
-                                fail!()
-                            }
-                            None => fail!()
-                        }
-                    }
-                }
-                _ => fail!("method_with_name")
-            }
-        } else {
-            csearch::get_impl_method(ccx.sess.cstore, impl_id, name)
+    if impl_id.crate == ast::local_crate {
+        match ccx.tcx.items.get_copy(&impl_id.node) {
+          ast_map::node_item(@ast::item {
+                node: ast::item_impl(_, _, _, ref ms), _
+          }, _) => {
+              let did = method_from_methods(*ms, name);
+              if did.is_some() {
+                  return did.get();
+              } else {
+                  // Look for a default method
+                  let pmm = ccx.tcx.provided_methods;
+                  match pmm.find(&impl_id) {
+                      Some(pmis) => {
+                          for pmis.each |pmi| {
+                              if pmi.method_info.ident == name {
+                                  debug!("pmi.method_info.did = %?", pmi.method_info.did);
+                                  return pmi.method_info.did;
+                              }
+                          }
+                          fail!()
+                      }
+                      None => fail!()
+                  }
+              }
+          }
+          _ => fail!("method_with_name")
         }
+    } else {
+        csearch::get_impl_method(ccx.sess.cstore, impl_id, name)
     }
 }
 

trunk/src/librustc/middle/ty.rs

@@ -271,8 +271,6 @@ struct ctxt_ {
     // A cache for the trait_methods() routine
     trait_methods_cache: @mut HashMap<def_id, @~[@Method]>,
 
-    impl_trait_cache: @mut HashMap<ast::def_id, Option<@ty::TraitRef>>,
-
     trait_refs: @mut HashMap<node_id, @TraitRef>,
     trait_defs: @mut HashMap<def_id, @TraitDef>,
 
@@ -969,7 +967,6 @@ pub fn mk_ctxt(s: session::Session,
         methods: @mut HashMap::new(),
         trait_method_def_ids: @mut HashMap::new(),
         trait_methods_cache: @mut HashMap::new(),
-        impl_trait_cache: @mut HashMap::new(),
         ty_param_defs: @mut HashMap::new(),
         adjustments: @mut HashMap::new(),
         normalized_cache: new_ty_hash(),
@@ -3752,24 +3749,22 @@ pub fn trait_method_def_ids(cx: ctxt, id: ast::def_id) -> @~[def_id] {
 }
 
 pub fn impl_trait_ref(cx: ctxt, id: ast::def_id) -> Option<@TraitRef> {
-    *do cx.impl_trait_cache.find_or_insert_with(id) |_| {
-        if id.crate == ast::local_crate {
-            debug!("(impl_trait_ref) searching for trait impl %?", id);
-            match cx.items.find(&id.node) {
-                Some(&ast_map::node_item(@ast::item {
-                                         node: ast::item_impl(_, opt_trait, _, _),
-                                         _},
-                                         _)) => {
-                    match opt_trait {
-                        Some(t) => Some(ty::node_id_to_trait_ref(cx, t.ref_id)),
-                        None => None
-                    }
-                }
-                _ => None
-            }
-        } else {
-            csearch::get_impl_trait(cx, id)
+    if id.crate == ast::local_crate {
+        debug!("(impl_trait_ref) searching for trait impl %?", id);
+        match cx.items.find(&id.node) {
+           Some(&ast_map::node_item(@ast::item {
+                        node: ast::item_impl(_, opt_trait, _, _),
+                        _},
+                    _)) => {
+               match opt_trait {
+                   Some(t) => Some(ty::node_id_to_trait_ref(cx, t.ref_id)),
+                   None => None
+               }
+           }
+           _ => None
         }
+    } else {
+        csearch::get_impl_trait(cx, id)
     }
 }
 

trunk/src/libstd/core.rc

@@ -232,3 +232,4 @@ mod std {
     pub use str;
     pub use os;
 }
+

trunk/src/libstd/rt/comm.rs

@@ -615,3 +615,4 @@ mod test {
         }
     }
 }
+

trunk/src/libstd/rt/io/stdio.rs

@@ -50,3 +50,4 @@ impl Writer for StdWriter {
 
     fn flush(&mut self) { fail!() }
 }
+

trunk/src/libstd/rt/task.rs

@@ -228,3 +228,4 @@ mod test {
         }
     }
 }
+

trunk/src/libstd/rt/test.rs

@@ -189,3 +189,4 @@ pub fn stress_factor() -> uint {
         None => 1
     }
 }
+

trunk/src/libstd/vec.rs

@@ -1002,31 +1002,33 @@ pub fn retain<T>(v: &mut ~[T], f: &fn(t: &T) -> bool) {
 }
 
 /// Flattens a vector of vectors of T into a single vector of T.
-pub fn concat<T:Copy>(v: &[~[T]]) -> ~[T] { v.concat() }
+pub fn concat<T:Copy>(v: &[~[T]]) -> ~[T] { v.concat_vec() }
 
 /// Concatenate a vector of vectors, placing a given separator between each
-pub fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] { v.connect(sep) }
+pub fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] { v.connect_vec(sep) }
 
 /// Flattens a vector of vectors of T into a single vector of T.
-pub fn concat_slices<T:Copy>(v: &[&[T]]) -> ~[T] { v.concat() }
+pub fn concat_slices<T:Copy>(v: &[&[T]]) -> ~[T] { v.concat_vec() }
 
 /// Concatenate a vector of vectors, placing a given separator between each
-pub fn connect_slices<T:Copy>(v: &[&[T]], sep: &T) -> ~[T] { v.connect(sep) }
+pub fn connect_slices<T:Copy>(v: &[&[T]], sep: &T) -> ~[T] { v.connect_vec(sep) }
 
 #[allow(missing_doc)]
 pub trait VectorVector<T> {
-    pub fn concat(&self) -> ~[T];
-    pub fn connect(&self, sep: &T) -> ~[T];
+    // FIXME #5898: calling these .concat and .connect conflicts with
+    // StrVector::con{cat,nect}, since they have generic contents.
+    pub fn concat_vec(&self) -> ~[T];
+    pub fn connect_vec(&self, sep: &T) -> ~[T];
 }
 
 impl<'self, T:Copy> VectorVector<T> for &'self [~[T]] {
     /// Flattens a vector of slices of T into a single vector of T.
-    pub fn concat(&self) -> ~[T] {
+    pub fn concat_vec(&self) -> ~[T] {
         self.flat_map(|&inner| inner)
     }
 
     /// Concatenate a vector of vectors, placing a given separator between each.
-    pub fn connect(&self, sep: &T) -> ~[T] {
+    pub fn connect_vec(&self, sep: &T) -> ~[T] {
         let mut r = ~[];
         let mut first = true;
         for self.each |&inner| {
@@ -1039,12 +1041,12 @@ impl<'self, T:Copy> VectorVector<T> for &'self [~[T]] {
 
 impl<'self, T:Copy> VectorVector<T> for &'self [&'self [T]] {
     /// Flattens a vector of slices of T into a single vector of T.
-    pub fn concat(&self) -> ~[T] {
+    pub fn concat_vec(&self) -> ~[T] {
         self.flat_map(|&inner| inner.to_owned())
     }
 
     /// Concatenate a vector of slices, placing a given separator between each.
-    pub fn connect(&self, sep: &T) -> ~[T] {
+    pub fn connect_vec(&self, sep: &T) -> ~[T] {
         let mut r = ~[];
         let mut first = true;
         for self.each |&inner| {
@@ -3704,25 +3706,25 @@ mod tests {
     #[test]
     fn test_concat() {
         assert_eq!(concat([~[1], ~[2,3]]), ~[1, 2, 3]);
-        assert_eq!([~[1], ~[2,3]].concat(), ~[1, 2, 3]);
+        assert_eq!([~[1], ~[2,3]].concat_vec(), ~[1, 2, 3]);
 
         assert_eq!(concat_slices([&[1], &[2,3]]), ~[1, 2, 3]);
-        assert_eq!([&[1], &[2,3]].concat(), ~[1, 2, 3]);
+        assert_eq!([&[1], &[2,3]].concat_vec(), ~[1, 2, 3]);
     }
 
     #[test]
     fn test_connect() {
         assert_eq!(connect([], &0), ~[]);
         assert_eq!(connect([~[1], ~[2, 3]], &0), ~[1, 0, 2, 3]);
         assert_eq!(connect([~[1], ~[2], ~[3]], &0), ~[1, 0, 2, 0, 3]);
-        assert_eq!([~[1], ~[2, 3]].connect(&0), ~[1, 0, 2, 3]);
-        assert_eq!([~[1], ~[2], ~[3]].connect(&0), ~[1, 0, 2, 0, 3]);
+        assert_eq!([~[1], ~[2, 3]].connect_vec(&0), ~[1, 0, 2, 3]);
+        assert_eq!([~[1], ~[2], ~[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]);
 
         assert_eq!(connect_slices([], &0), ~[]);
         assert_eq!(connect_slices([&[1], &[2, 3]], &0), ~[1, 0, 2, 3]);
         assert_eq!(connect_slices([&[1], &[2], &[3]], &0), ~[1, 0, 2, 0, 3]);
-        assert_eq!([&[1], &[2, 3]].connect(&0), ~[1, 0, 2, 3]);
-        assert_eq!([&[1], &[2], &[3]].connect(&0), ~[1, 0, 2, 0, 3]);
+        assert_eq!([&[1], &[2, 3]].connect_vec(&0), ~[1, 0, 2, 3]);
+        assert_eq!([&[1], &[2], &[3]].connect_vec(&0), ~[1, 0, 2, 0, 3]);
     }
 
     #[test]

trunk/src/libsyntax/ext/pipes/ast_builder.rs

@@ -63,3 +63,4 @@ impl append_types for @ast::Path {
         }
     }
 }
+

trunk/src/rt/rust_env.cpp

@@ -156,3 +156,4 @@ free_env(rust_env *env) {
     free(env->rust_seed);
     free(env);
 }
+

trunk/src/rustllvm/rustllvm.h

@@ -54,3 +54,4 @@
 #include <fcntl.h>
 #include <unistd.h>
 #endif
+

trunk/src/test/auxiliary/anon-extern-mod-cross-crate-1.rs

@@ -20,3 +20,4 @@ use std::libc;
 extern {
     pub fn rust_get_argc() -> libc::c_int;
 }
+

trunk/src/test/auxiliary/private_variant_xc.rs

@@ -2,3 +2,4 @@ pub enum Foo {
     pub Bar,
     priv Baz,
 }
+

trunk/src/test/auxiliary/use_from_trait_xc.rs

@@ -7,3 +7,4 @@ struct Foo;
 impl Foo {
     pub fn new() {}
 }
+

trunk/src/test/compile-fail/lint-unused-import-tricky-names.rs

@@ -44,3 +44,4 @@ mod issue6935 {
 }
 
 fn main(){}
+

trunk/src/test/compile-fail/private-variant-xc.rs

@@ -6,3 +6,4 @@ pub fn main() {
     let _ = private_variant_xc::Bar;
     let _ = private_variant_xc::Baz;    //~ ERROR unresolved name
 }
+

trunk/src/test/compile-fail/use-from-trait-xc.rs

@@ -9,3 +9,4 @@ use use_from_trait_xc::Foo::new;    //~ ERROR cannot import from a trait or type
 
 fn main() {
 }
+

trunk/src/test/compile-fail/use-from-trait.rs

@@ -14,3 +14,4 @@ impl Foo {
 }
 
 fn main() {}
+

trunk/src/test/run-pass/const-struct-offsets.rs

@@ -11,3 +11,4 @@ struct Bar {
 static bar: Bar = Bar { i: 0, v: IntVal(0) };
 
 fn main() {}
+

trunk/src/test/run-pass/issue-4735.rs

@@ -26,3 +26,5 @@ fn main() {
     let p = unsafe { transmute::<~int, *c_void>(t) };
     let z = NonCopyable(p);
 }
+
+

trunk/src/test/run-pass/monomorphize-abi-alignment.rs

@@ -24,8 +24,8 @@ struct A((u32, u32));
 struct B(u64);
 
 pub fn main() {
-    static Ca: S<A> = S { i: 0, t: A((13, 104)) };
-    static Cb: S<B> = S { i: 0, t: B(31337) };
-    assert_eq!(*(Ca.unwrap()), (13, 104));
-    assert_eq!(*(Cb.unwrap()), 31337);
+	static Ca: S<A> = S { i: 0, t: A((13, 104)) };
+	static Cb: S<B> = S { i: 0, t: B(31337) };
+	assert_eq!(*(Ca.unwrap()), (13, 104));
+	assert_eq!(*(Cb.unwrap()), 31337);
 }

trunk/src/test/run-pass/multi-let.rs

@@ -13,3 +13,4 @@ pub fn main() {
     let y = x;
     assert!((y == 10));
 }
+

trunk/src/test/run-pass/pub-extern-privacy.rs

@@ -11,3 +11,4 @@ fn main() {
         a::free(transmute(0));
     }
 }
+