---

yaml
---
r: 60200
b: refs/heads/master
c: 7d4bb90
h: refs/heads/master
v: v3

Author: emberian

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d546493096f35e68cbcd9b5d3d7654e7a9345744
+refs/heads/master: 7d4bb90e76207f3715126562fd50193fda97ff49
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/libcore/unstable/intrinsics.rs

@@ -42,17 +42,12 @@ pub extern "rust-intrinsic" {
 
     pub fn get_tydesc<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;
+    pub fn init<T>() -> T;
 
     #[cfg(not(stage0))]
     pub unsafe fn uninit<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 forget<T>(_: T) -> ();
 
     pub fn needs_drop<T>() -> bool;
 

trunk/src/librustc/middle/resolve.rs

@@ -1909,7 +1909,6 @@ pub impl Resolver {
             }
 
             if self.unresolved_imports == prev_unresolved_imports {
-                self.session.err(~"failed to resolve imports");
                 self.report_unresolved_imports(module_root);
                 break;
             }

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

@@ -968,10 +968,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
                 }
 
                 fn get_val(bcx: block, did: ast::def_id, const_ty: ty::t)
-                           -> ValueRef {
-                    // For external constants, we don't inline.
-                    let extern_const_values =
-                        &mut *bcx.ccx().extern_const_values;
+                    -> ValueRef {
                     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
@@ -980,24 +977,25 @@ 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 {
-                        match extern_const_values.find(&did) {
-                            None => {}  // Continue.
-                            Some(llval) => {
-                                return *llval;
+                        // 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
+                                }
                             }
-                        }
-
-                        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
+                            Some(llval) => *llval
                         }
                     }
                 }