---

yaml
---
r: 59059
b: refs/heads/incoming
c: 7652f3d
h: refs/heads/master
i:
  59057: 30410e8
  59055: a30d64d
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: fd5a3520d5fbb009b2a5de8cf5ed164f28418cb1
+refs/heads/incoming: 7652f3ddb8f3c4fd281e6ec0bd8fc0d9b8ed857b
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/core.rc

@@ -228,7 +228,6 @@ pub mod rand;
 pub mod run;
 pub mod sys;
 pub mod cast;
-pub mod flate;
 pub mod repr;
 pub mod cleanup;
 pub mod reflect;

branches/incoming/src/libcore/to_str.rs

@@ -15,10 +15,6 @@ The `ToStr` trait for converting to strings
 */
 
 use str;
-use hashmap::HashMap;
-use container::Map;
-use hash::Hash;
-use cmp::Eq;
 
 pub trait ToStr {
     fn to_str(&self) -> ~str;
@@ -50,26 +46,6 @@ impl<A:ToStr> ToStr for (A,) {
     }
 }
 
-impl<A:ToStr+Hash+Eq, B:ToStr+Hash+Eq> ToStr for HashMap<A, B> {
-    #[inline(always)]
-    fn to_str(&self) -> ~str {
-        let mut acc = ~"{", first = true;
-        for self.each |key, value| {
-            if first {
-                first = false;
-            }
-            else {
-                str::push_str(&mut acc, ~", ");
-            }
-            str::push_str(&mut acc, key.to_str());
-            str::push_str(&mut acc, ~" : ");
-            str::push_str(&mut acc, value.to_str());
-        }
-        str::push_char(&mut acc, '}');
-        acc
-    }
-}
-
 impl<A:ToStr,B:ToStr> ToStr for (A, B) {
     #[inline(always)]
     fn to_str(&self) -> ~str {
@@ -144,7 +120,6 @@ impl<A:ToStr> ToStr for @[A] {
 #[cfg(test)]
 #[allow(non_implicitly_copyable_typarams)]
 mod tests {
-    use hashmap::HashMap;
     #[test]
     fn test_simple_types() {
         assert!(1i.to_str() == ~"1");
@@ -174,16 +149,4 @@ mod tests {
         assert!((~[~[], ~[1], ~[1, 1]]).to_str() ==
                ~"[[], [1], [1, 1]]");
     }
-
-    // #[test]
-    // fn test_hashmap() {
-    //     let mut table: HashMap<int, int> = HashMap::new();
-    //     let mut empty: HashMap<int, int> = HashMap::new();
-
-    //     table.insert(3, 4);
-    //     table.insert(1, 2);
-
-    //     assert!(table.to_str() == ~"{1 : 2, 3 : 4}");
-    //     assert!(empty.to_str() == ~"{}");
-    //}
-}
+}

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

@@ -42,12 +42,17 @@ pub extern "rust-intrinsic" {
 
     pub fn get_tydesc<T>() -> *();
 
-    pub fn init<T>() -> T;
+    /// init is unsafe because it returns a zeroed-out datum,
+    /// which is unsafe unless T is POD. We don't have a POD
+    /// kind yet. (See #4074)
+    pub unsafe fn init<T>() -> T;
 
     #[cfg(not(stage0))]
     pub unsafe fn uninit<T>() -> T;
 
-    pub fn forget<T>(_: T) -> ();
+    /// forget is unsafe because the caller is responsible for
+    /// ensuring the argument is deallocated already
+    pub unsafe fn forget<T>(_: T) -> ();
 
     pub fn needs_drop<T>() -> bool;
 

branches/incoming/src/librustc/metadata/encoder.rs

@@ -20,7 +20,7 @@ use middle::ty;
 use middle;
 use util::ppaux::ty_to_str;
 
-use core::flate;
+use std::flate;
 use core::hash::HashUtil;
 use core::hashmap::HashMap;
 use std::serialize::Encodable;

branches/incoming/src/librustc/metadata/loader.rs

@@ -22,7 +22,7 @@ use syntax::parse::token::ident_interner;
 use syntax::print::pprust;
 use syntax::{ast, attr};
 
-use core::flate;
+use std::flate;
 use core::os::consts::{macos, freebsd, linux, android, win32};
 
 pub enum os {

branches/incoming/src/librustc/middle/trans/expr.rs

@@ -968,7 +968,10 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
                 }
 
                 fn get_val(bcx: block, did: ast::def_id, const_ty: ty::t)
-                    -> ValueRef {
+                           -> ValueRef {
+                    // For external constants, we don't inline.
+                    let extern_const_values =
+                        &mut *bcx.ccx().extern_const_values;
                     if did.crate == ast::local_crate {
                         // The LLVM global has the type of its initializer,
                         // which may not be equal to the enum's type for
@@ -977,25 +980,24 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
                                     base::get_item_val(bcx.ccx(), did.node),
                                     T_ptr(type_of(bcx.ccx(), const_ty)))
                     } else {
-                        // For external constants, we don't inline.
-                        match bcx.ccx().extern_const_values.find(&did) {
-                            None => {
-                                unsafe {
-                                    let llty = type_of(bcx.ccx(), const_ty);
-                                    let symbol = csearch::get_symbol(
-                                        bcx.ccx().sess.cstore,
-                                        did);
-                                    let llval = llvm::LLVMAddGlobal(
-                                        bcx.ccx().llmod,
-                                        llty,
-                                        transmute::<&u8,*i8>(&symbol[0]));
-                                    bcx.ccx().extern_const_values.insert(
-                                        did,
-                                        llval);
-                                    llval
-                                }
+                        match extern_const_values.find(&did) {
+                            None => {}  // Continue.
+                            Some(llval) => {
+                                return *llval;
                             }
-                            Some(llval) => *llval
+                        }
+
+                        unsafe {
+                            let llty = type_of(bcx.ccx(), const_ty);
+                            let symbol = csearch::get_symbol(
+                                bcx.ccx().sess.cstore,
+                                did);
+                            let llval = llvm::LLVMAddGlobal(
+                                bcx.ccx().llmod,
+                                llty,
+                                transmute::<&u8,*i8>(&symbol[0]));
+                            extern_const_values.insert(did, llval);
+                            llval
                         }
                     }
                 }

branches/incoming/src/libcore/flate.rs renamed to branches/incoming/src/libstd/flate.rs

@@ -15,14 +15,14 @@ Simple compression
 */
 
 use libc;
-use libc::{c_void, size_t, c_int};
+use core::libc::{c_void, size_t, c_int};
 use vec;
 
-#[cfg(test)] use rand;
-#[cfg(test)] use rand::RngUtil;
+#[cfg(test)] use core::rand;
+#[cfg(test)] use core::rand::RngUtil;
 
 pub mod rustrt {
-    use libc::{c_int, c_void, size_t};
+    use core::libc::{c_int, c_void, size_t};
 
     #[link_name = "rustrt"]
     pub extern {

branches/incoming/src/libstd/std.rc

@@ -107,6 +107,7 @@ pub mod complex;
 pub mod stats;
 pub mod semver;
 pub mod fileinput;
+pub mod flate;
 
 #[cfg(unicode)]
 mod unicode;

branches/incoming/src/test/compile-fail/forget-init-unsafe.rs

@@ -0,0 +1,17 @@
+// Copyright 2013 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.
+
+use core::unstable::intrinsics::{init, forget};
+
+// Test that the `forget` and `init` intrinsics are really unsafe
+pub fn main() {
+    let stuff = init::<int>(); //~ ERROR access to unsafe function requires unsafe
+    forget(stuff);             //~ ERROR access to unsafe function requires unsafe
+}