---

yaml
---
r: 140644
b: refs/heads/try2
c: 050c744
h: refs/heads/master
v: v3

Author: James Miller

[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: ce9c0225c451c00c3eebe4e496185143a18814b9
+refs/heads/try2: 050c744c23a8e01407452bc64ca63f92554afee2
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/runtest.rs

@@ -764,7 +764,7 @@ fn _arm_exec_compiled_test(config: config, props: TestProps,
     logv(config, fmt!("executing (%s) %s", config.target, cmdline));
 
     // adb shell dose not forward stdout and stderr of internal result
-    // to stdout and stderr separately but to stdout only
+    // to stdout and stderr seperately but to stdout only
     let mut newargs_out = ~[];
     let mut newargs_err = ~[];
     let subargs = args.args;

branches/try2/src/libcore/at_vec.rs

@@ -52,7 +52,7 @@ pub fn capacity<T>(v: @[T]) -> uint {
  * # Arguments
  *
  * * size - An initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -70,7 +70,7 @@ pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> @[A] {
  *
  * # Arguments
  *
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */
@@ -87,7 +87,7 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> @[A] {
  * # Arguments
  *
  * * size - An option, maybe containing initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */

branches/try2/src/libcore/core.rc

@@ -60,6 +60,7 @@ they contained the following prologue:
 // Don't link to core. We are core.
 #[no_core];
 
+#[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
 

branches/try2/src/libcore/iter.rs

@@ -17,7 +17,8 @@ breaking out of iteration. The adaptors in the module work with any such iterato
 tied to specific traits. For example:
 
 ~~~~
-println(iter::to_vec(|f| uint::range(0, 20, f)).to_str());
+use core::iter::iter_to_vec;
+println(iter_to_vec(|f| uint::range(0, 20, f)).to_str());
 ~~~~
 
 An external iterator object implementing the interface in the `iterator` module can be used as an
@@ -54,12 +55,12 @@ pub trait Times {
  *
  * ~~~
  * let xs = ~[1, 2, 3];
- * let ys = do iter::to_vec |f| { xs.each(|x| f(*x)) };
+ * let ys = do iter_to_vec |f| { xs.each(|x| f(*x)) };
  * assert_eq!(xs, ys);
  * ~~~
  */
 #[inline(always)]
-pub fn to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
+pub fn iter_to_vec<T>(iter: &fn(f: &fn(T) -> bool)) -> ~[T] {
     let mut v = ~[];
     for iter |x| { v.push(x) }
     v
@@ -184,9 +185,9 @@ mod tests {
     use prelude::*;
 
     #[test]
-    fn test_to_vec() {
+    fn test_iter_to_vec() {
         let xs = ~[1, 2, 3];
-        let ys = do to_vec |f| { xs.each(|x| f(*x)) };
+        let ys = do iter_to_vec |f| { xs.each(|x| f(*x)) };
         assert_eq!(xs, ys);
     }
 

branches/try2/src/libcore/iterator.rs

@@ -378,7 +378,7 @@ mod tests {
     #[test]
     fn test_counter_to_vec() {
         let mut it = Counter::new(0, 5).take(10);
-        let xs = iter::to_vec(|f| it.advance(f));
+        let xs = iter::iter_to_vec(|f| it.advance(f));
         assert_eq!(xs, ~[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
     }
 

branches/try2/src/libcore/rt/io/extensions.rs

@@ -11,7 +11,7 @@
 //! Utility mixins that apply to all Readers and Writers
 
 // XXX: Not sure how this should be structured
-// XXX: Iteration should probably be considered separately
+// XXX: Iteration should probably be considered seperately
 
 pub trait ReaderUtil {
 

branches/try2/src/libcore/task/local_data_priv.rs

@@ -133,7 +133,7 @@ unsafe fn get_newsched_local_map(local: *mut LocalStorage) -> TaskLocalMap {
 
 unsafe fn key_to_key_value<T: 'static>(key: LocalDataKey<T>) -> *libc::c_void {
     // Keys are closures, which are (fnptr,envptr) pairs. Use fnptr.
-    // Use reinterpret_cast -- transmute would leak (forget) the closure.
+    // Use reintepret_cast -- transmute would leak (forget) the closure.
     let pair: (*libc::c_void, *libc::c_void) = cast::transmute_copy(&key);
     pair.first()
 }

branches/try2/src/libcore/unstable/intrinsics.rs

@@ -44,6 +44,9 @@ pub extern "rust-intrinsic" {
 
     pub fn init<T>() -> T;
 
+    #[cfg(not(stage0))]
+    pub unsafe fn uninit<T>() -> T;
+
     pub fn forget<T>(_: T) -> ();
 
     pub fn needs_drop<T>() -> bool;

branches/try2/src/libcore/vec.rs

@@ -219,7 +219,7 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> ~[A] {
  * # Arguments
  *
  * * size - An option, maybe containing initial size of the vector to reserve
- * * builder - A function that will construct the vector. It receives
+ * * builder - A function that will construct the vector. It recieves
  *             as an argument a function that will push an element
  *             onto the vector being constructed.
  */

branches/try2/src/librustc/driver/session.rs

@@ -237,7 +237,6 @@ pub impl Session_ {
                  msg: &str) {
         let level = lint::get_lint_settings_level(
             self.lint_settings, lint_mode, expr_id, item_id);
-        let msg = fmt!("%s [-W %s]", msg, lint::get_lint_name(lint_mode));
         self.span_lint_level(level, span, msg);
     }
     fn next_node_id(@self) -> ast::node_id {

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

@@ -237,14 +237,6 @@ pub fn get_lint_dict() -> LintDict {
     return @map;
 }
 
-pub fn get_lint_name(lint_mode: lint) -> ~str {
-    for lint_table.each |&(name, spec)| {
-        if spec.lint == lint_mode {
-            return name.to_str();
-        }
-    }
-    fail!();
-}
 // This is a highly not-optimal set of data structure decisions.
 type LintModes = @mut SmallIntMap<level>;
 type LintModeMap = @mut HashMap<ast::node_id, LintModes>;

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

@@ -715,6 +715,9 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                 Store(bcx, C_null(lltp_ty), fcx.llretptr.get());
             }
         }
+        ~"uninit" => {
+            // Do nothing, this is effectively a no-op
+        }
         ~"forget" => {}
         ~"transmute" => {
             let (in_type, out_type) = (substs.tys[0], substs.tys[1]);

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

@@ -87,7 +87,7 @@ pub fn nonzero_llsize_of(cx: @CrateContext, t: TypeRef) -> ValueRef {
 }
 
 // Returns the preferred alignment of the given type for the current target.
-// The preferred alignment may be larger than the alignment used when
+// The preffered alignment may be larger than the alignment used when
 // packing the type into structs. This will be used for things like
 // allocations inside a stack frame, which LLVM has a free hand in.
 pub fn llalign_of_pref(cx: @CrateContext, t: TypeRef) -> uint {
@@ -96,7 +96,7 @@ pub fn llalign_of_pref(cx: @CrateContext, t: TypeRef) -> uint {
     }
 }
 
-// Returns the minimum alignment of a type required by the platform.
+// Returns the minimum alignment of a type required by the plattform.
 // This is the alignment that will be used for struct fields, arrays,
 // and similar ABI-mandated things.
 pub fn llalign_of_min(cx: @CrateContext, t: TypeRef) -> uint {

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

@@ -118,7 +118,7 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint)
         if abi.is_intrinsic() {
             let flags = match *cx.ccx.sess.str_of(i.ident) {
                 ~"size_of"  | ~"pref_align_of" | ~"min_align_of" |
-                ~"init"     | ~"transmute"     | ~"move_val"     |
+                ~"uninit"   | ~"init" | ~"transmute" | ~"move_val" |
                 ~"move_val_init" => use_repr,
 
                 ~"get_tydesc" | ~"needs_drop" => use_tydesc,

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -3447,6 +3447,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
       ~"size_of" |
       ~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint()),
       ~"init" => (1u, ~[], param(ccx, 0u)),
+      ~"uninit" => (1u, ~[], param(ccx, 0u)),
       ~"forget" => (1u, ~[arg(param(ccx, 0u))], ty::mk_nil()),
       ~"transmute" => (2, ~[ arg(param(ccx, 0)) ], param(ccx, 1)),
       ~"move_val" | ~"move_val_init" => {

branches/try2/src/librustc/middle/typeck/check/vtable.rs

@@ -31,7 +31,7 @@ use syntax::print::pprust::expr_to_str;
 use syntax::visit;
 
 // vtable resolution looks for places where trait bounds are
-// substituted in and figures out which vtable is used. There is some
+// subsituted in and figures out which vtable is used. There is some
 // extra complication thrown in to support early "opportunistic"
 // vtable resolution. This is a hacky mechanism that is invoked while
 // typechecking function calls (after typechecking non-closure

branches/try2/src/libstd/arc.rs

@@ -498,7 +498,7 @@ mod tests {
 
             let arc_v = p.recv();
 
-            let v = copy *arc::get::<~[int]>(&arc_v);
+            let v = *arc::get::<~[int]>(&arc_v);
             assert!(v[3] == 4);
         };
 

branches/try2/src/libstd/arena.rs

@@ -20,7 +20,7 @@
 // calling the destructors on them.
 // One subtle point that needs to be addressed is how to handle
 // failures while running the user provided initializer function. It
-// is important to not run the destructor on uninitialized objects, but
+// is important to not run the destructor on uninitalized objects, but
 // how to detect them is somewhat subtle. Since alloc() can be invoked
 // recursively, it is not sufficient to simply exclude the most recent
 // object. To solve this without requiring extra space, we use the low

branches/try2/src/libstd/flatpipes.rs

@@ -15,7 +15,7 @@ or transformed to and from, byte vectors.
 
 The `FlatPort` and `FlatChan` types implement the generic channel and
 port interface for arbitrary types and transport strategies. It can
-particularly be used to send and receive serializable types over I/O
+particularly be used to send and recieve serializable types over I/O
 streams.
 
 `FlatPort` and `FlatChan` implement the same comm traits as pipe-based
@@ -55,7 +55,7 @@ use core::sys::size_of;
 use core::vec;
 
 /**
-A FlatPort, consisting of a `BytePort` that receives byte vectors,
+A FlatPort, consisting of a `BytePort` that recieves byte vectors,
 and an `Unflattener` that converts the bytes to a value.
 
 Create using the constructors in the `serial` and `pod` modules.
@@ -821,7 +821,7 @@ mod test {
             }
         }
 
-        // Receiver task
+        // Reciever task
         do task::spawn || {
             // Wait for a connection
             let (conn, res_chan) = accept_port.recv();
@@ -840,7 +840,7 @@ mod test {
 
             for int::range(0, 10) |i| {
                 let j = port.recv();
-                debug!("received %?", j);
+                debug!("receieved %?", j);
                 assert!(i == j);
             }
 

branches/try2/src/libstd/future.rs

@@ -238,8 +238,8 @@ mod test {
 
     #[test]
     fn test_sendable_future() {
-        let expected = "schlorf";
-        let f = Cell(do spawn { expected });
+        let expected = ~"schlorf";
+        let f = Cell(do spawn { copy expected });
         do task::spawn {
             let mut f = f.take();
             let actual = f.get();