---

yaml
---
r: 58261
b: refs/heads/auto
c: 050c744
h: refs/heads/master
i:
  58259: 2fb8647
v: v3

Author: James Miller

[refs]

@@ -14,6 +14,6 @@ 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: 5617916726186290710dade90057683904a5f215
+refs/heads/auto: 050c744c23a8e01407452bc64ca63f92554afee2
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/src/test/run-pass/intrinsic-uninit.rs

@@ -0,0 +1,19 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod rusti {
+    #[abi = "rust-intrinsic"]
+    pub extern "rust-intrinsic" {
+        fn uninit<T>() -> T;
+    }
+}
+pub fn main() {
+    let _a : int = unsafe {rusti::uninit()};
+}