---

yaml
---
r: 174359
b: refs/heads/master
c: 0859e5e
h: refs/heads/master
i:
  174357: e63d3de
  174355: b4f6348
  174351: bf963dd
v: v3

Author: Aatch

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7b87900d72cf53037119e3bac1506a9786ca508a
+refs/heads/master: 0859e5ebb319ceddcce01ddb63470d8f59860aba
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9006c3c0f14be45da8ffeba43d354d088e366c83
 refs/heads/try: 08f6380a9f0b866796080094f44fe25ea5636547

trunk/src/liblibc/lib.rs

@@ -2207,10 +2207,10 @@ pub mod consts {
             pub const IPPROTO_TCP: c_int = 6;
             pub const IPPROTO_IP: c_int = 0;
             pub const IPPROTO_IPV6: c_int = 41;
-            pub const IP_MULTICAST_TTL: c_int = 10;
-            pub const IP_MULTICAST_LOOP: c_int = 11;
-            pub const IP_ADD_MEMBERSHIP: c_int = 12;
-            pub const IP_DROP_MEMBERSHIP: c_int = 13;
+            pub const IP_MULTICAST_TTL: c_int = 3;
+            pub const IP_MULTICAST_LOOP: c_int = 4;
+            pub const IP_ADD_MEMBERSHIP: c_int = 5;
+            pub const IP_DROP_MEMBERSHIP: c_int = 6;
             pub const IPV6_ADD_MEMBERSHIP: c_int = 5;
             pub const IPV6_DROP_MEMBERSHIP: c_int = 6;
             pub const IP_TTL: c_int = 4;

trunk/src/librustc/middle/infer/error_reporting.rs

@@ -1177,7 +1177,6 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
             ast::Return(ref ret_ty) => ast::Return(
                 self.rebuild_arg_ty_or_output(&**ret_ty, lifetime, anon_nums, region_names)
             ),
-            ast::DefaultReturn(span) => ast::DefaultReturn(span),
             ast::NoReturn(span) => ast::NoReturn(span)
         }
     }

trunk/src/librustc_trans/trans/debuginfo.rs

@@ -1450,15 +1450,18 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         let mut signature = Vec::with_capacity(fn_decl.inputs.len() + 1);
 
         // Return type -- llvm::DIBuilder wants this at index 0
-        assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
-        let return_type = ty::node_id_to_type(cx.tcx(), fn_ast_id);
-        let return_type = monomorphize::apply_param_substs(cx.tcx(),
-                                                           param_substs,
-                                                           &return_type);
-        if ty::type_is_nil(return_type) {
-            signature.push(ptr::null_mut())
-        } else {
-            signature.push(type_metadata(cx, return_type, codemap::DUMMY_SP));
+        match fn_decl.output {
+            ast::Return(ref ret_ty) if ret_ty.node == ast::TyTup(vec![]) =>
+                signature.push(ptr::null_mut()),
+            _ => {
+                assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
+
+                let return_type = ty::node_id_to_type(cx.tcx(), fn_ast_id);
+                let return_type = monomorphize::apply_param_substs(cx.tcx(),
+                                                                   param_substs,
+                                                                   &return_type);
+                signature.push(type_metadata(cx, return_type, codemap::DUMMY_SP));
+            }
         }
 
         // Arguments types

trunk/src/librustc_trans/trans/foreign.rs

@@ -445,8 +445,9 @@ fn gate_simd_ffi(tcx: &ty::ctxt, decl: &ast::FnDecl, ty: &ty::BareFnTy) {
         for (input, ty) in decl.inputs.iter().zip(sig.inputs.iter()) {
             check(&*input.ty, *ty)
         }
-        if let ast::Return(ref ty) = decl.output {
-            check(&**ty, sig.output.unwrap())
+        match decl.output {
+            ast::NoReturn(_) => {}
+            ast::Return(ref ty) => check(&**ty, sig.output.unwrap())
         }
     }
 }

trunk/src/librustc_trans/trans/intrinsic.rs

@@ -361,12 +361,11 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
         }
         (_, "init") => {
             let tp_ty = *substs.types.get(FnSpace, 0);
-            let lltp_ty = type_of::arg_type_of(ccx, tp_ty);
-            if return_type_is_void(ccx, tp_ty) {
-                C_nil(ccx)
-            } else {
-                C_null(lltp_ty)
+            if !return_type_is_void(ccx, tp_ty) {
+                // Just zero out the stack slot
+                zero_mem(bcx, llresult, tp_ty);
             }
+            C_nil(ccx)
         }
         // Effectively no-ops
         (_, "uninit") | (_, "forget") => {

trunk/src/librustc_typeck/astconv.rs

@@ -1359,8 +1359,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx>,
                                                               implied_output_region,
                                                               lifetimes_for_params,
                                                               &**output)),
-        ast::DefaultReturn(..) => ty::FnConverging(ty::mk_nil(this.tcx())),
-        ast::NoReturn(..) => ty::FnDiverging
+        ast::NoReturn(_) => ty::FnDiverging
     };
 
     (ty::BareFnTy {
@@ -1487,21 +1486,14 @@ pub fn ty_of_closure<'tcx>(
 
     let expected_ret_ty = expected_sig.map(|e| e.output);
 
-    let is_infer = match decl.output {
-        ast::Return(ref output) if output.node == ast::TyInfer => true,
-        ast::DefaultReturn(..) => true,
-        _ => false
-    };
-
     let output_ty = match decl.output {
-        _ if is_infer && expected_ret_ty.is_some() =>
+        ast::Return(ref output) if output.node == ast::TyInfer && expected_ret_ty.is_some() =>
             expected_ret_ty.unwrap(),
-        _ if is_infer =>
-            ty::FnConverging(this.ty_infer(decl.output.span())),
+        ast::Return(ref output) if output.node == ast::TyInfer =>
+            ty::FnConverging(this.ty_infer(output.span)),
         ast::Return(ref output) =>
             ty::FnConverging(ast_ty_to_ty(this, &rb, &**output)),
-        ast::DefaultReturn(..) => unreachable!(),
-        ast::NoReturn(..) => ty::FnDiverging
+        ast::NoReturn(_) => ty::FnDiverging
     };
 
     debug!("ty_of_closure: input_tys={}", input_tys.repr(this.tcx()));

trunk/src/librustc_typeck/collect.rs

@@ -1488,9 +1488,7 @@ fn ty_of_foreign_fn_decl<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
     let output = match decl.output {
         ast::Return(ref ty) =>
             ty::FnConverging(ast_ty_to_ty(ccx, &rb, &**ty)),
-        ast::DefaultReturn(..) =>
-            ty::FnConverging(ty::mk_nil(ccx.tcx)),
-        ast::NoReturn(..) =>
+        ast::NoReturn(_) =>
             ty::FnDiverging
     };
 

trunk/src/librustdoc/clean/mod.rs

@@ -1141,16 +1141,14 @@ impl Clean<Argument> for ast::Arg {
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 pub enum FunctionRetTy {
     Return(Type),
-    DefaultReturn,
     NoReturn
 }
 
 impl Clean<FunctionRetTy> for ast::FunctionRetTy {
     fn clean(&self, cx: &DocContext) -> FunctionRetTy {
         match *self {
             ast::Return(ref typ) => Return(typ.clean(cx)),
-            ast::DefaultReturn(..) => DefaultReturn,
-            ast::NoReturn(..) => NoReturn
+            ast::NoReturn(_) => NoReturn
         }
     }
 }

trunk/src/librustdoc/html/format.rs

@@ -557,7 +557,6 @@ impl fmt::String for clean::FunctionRetTy {
         match *self {
             clean::Return(clean::Tuple(ref tys)) if tys.is_empty() => Ok(()),
             clean::Return(ref ty) => write!(f, " -> {}", ty),
-            clean::DefaultReturn => Ok(()),
             clean::NoReturn => write!(f, " -> !")
         }
     }

trunk/src/libstd/dynamic_lib.rs

@@ -52,14 +52,21 @@ impl DynamicLibrary {
     /// Lazily open a dynamic library. When passed None it gives a
     /// handle to the calling process
     pub fn open(filename: Option<&Path>) -> Result<DynamicLibrary, String> {
-        let maybe_library = dl::open(filename.map(|path| path.as_vec()));
-
-        // The dynamic library must not be constructed if there is
-        // an error opening the library so the destructor does not
-        // run.
-        match maybe_library {
-            Err(err) => Err(err),
-            Ok(handle) => Ok(DynamicLibrary { handle: handle })
+        unsafe {
+            let maybe_library = dl::check_for_errors_in(|| {
+                match filename {
+                    Some(name) => dl::open_external(name.as_vec()),
+                    None => dl::open_internal()
+                }
+            });
+
+            // The dynamic library must not be constructed if there is
+            // an error opening the library so the destructor does not
+            // run.
+            match maybe_library {
+                Err(err) => Err(err),
+                Ok(handle) => Ok(DynamicLibrary { handle: handle })
+            }
         }
     }
 
@@ -191,34 +198,22 @@ mod test {
           target_os = "ios",
           target_os = "freebsd",
           target_os = "dragonfly"))]
-mod dl {
+pub mod dl {
+    pub use self::Rtld::*;
     use prelude::v1::*;
 
     use ffi::{self, CString};
     use str;
     use libc;
     use ptr;
 
-    pub fn open(filename: Option<&[u8]>) -> Result<*mut u8, String> {
-        check_for_errors_in(|| {
-            unsafe {
-                match filename {
-                    Some(filename) => open_external(filename),
-                    None => open_internal(),
-                }
-            }
-        })
-    }
-
-    const LAZY: libc::c_int = 1;
-
-    unsafe fn open_external(filename: &[u8]) -> *mut u8 {
+    pub unsafe fn open_external(filename: &[u8]) -> *mut u8 {
         let s = CString::from_slice(filename);
-        dlopen(s.as_ptr(), LAZY) as *mut u8
+        dlopen(s.as_ptr(), Lazy as libc::c_int) as *mut u8
     }
 
-    unsafe fn open_internal() -> *mut u8 {
-        dlopen(ptr::null(), LAZY) as *mut u8
+    pub unsafe fn open_internal() -> *mut u8 {
+        dlopen(ptr::null(), Lazy as libc::c_int) as *mut u8
     }
 
     pub fn check_for_errors_in<T, F>(f: F) -> Result<T, String> where
@@ -254,6 +249,14 @@ mod dl {
         dlclose(handle as *mut libc::c_void); ()
     }
 
+    #[derive(Copy)]
+    pub enum Rtld {
+        Lazy = 1,
+        Now = 2,
+        Global = 256,
+        Local = 0,
+    }
+
     #[link_name = "dl"]
     extern {
         fn dlopen(filename: *const libc::c_char,
@@ -266,13 +269,11 @@ mod dl {
 }
 
 #[cfg(target_os = "windows")]
-mod dl {
+pub mod dl {
     use iter::IteratorExt;
     use libc;
-    use libc::consts::os::extra::ERROR_CALL_NOT_IMPLEMENTED;
     use ops::FnOnce;
     use os;
-    use option::Option::{self, Some, None};
     use ptr;
     use result::Result;
     use result::Result::{Ok, Err};
@@ -281,75 +282,19 @@ mod dl {
     use str;
     use string::String;
     use vec::Vec;
-    use sys::c::compat::kernel32::SetThreadErrorMode;
-
-    pub fn open(filename: Option<&[u8]>) -> Result<*mut u8, String> {
-        // disable "dll load failed" error dialog.
-        let mut use_thread_mode = true;
-        let prev_error_mode = unsafe {
-            // SEM_FAILCRITICALERRORS 0x01
-            let new_error_mode = 1;
-            let mut prev_error_mode = 0;
-            // Windows >= 7 supports thread error mode.
-            let result = SetThreadErrorMode(new_error_mode, &mut prev_error_mode);
-            if result == 0 {
-                let err = os::errno();
-                if err as libc::c_int == ERROR_CALL_NOT_IMPLEMENTED {
-                    use_thread_mode = false;
-                    // SetThreadErrorMode not found. use fallback solution: SetErrorMode()
-                    // Note that SetErrorMode is process-wide so this can cause race condition!
-                    // However, since even Windows APIs do not care of such problem (#20650),
-                    // we just assume SetErrorMode race is not a great deal.
-                    prev_error_mode = SetErrorMode(new_error_mode);
-                }
-            }
-            prev_error_mode
-        };
-
-        unsafe {
-            SetLastError(0);
-        }
-
-        let result = match filename {
-            Some(filename) => {
-                let filename_str = str::from_utf8(filename).unwrap();
-                let mut filename_str: Vec<u16> = filename_str.utf16_units().collect();
-                filename_str.push(0);
-                let result = unsafe {
-                    LoadLibraryW(filename_str.as_ptr() as *const libc::c_void)
-                };
-                // beware: Vec/String may change errno during drop!
-                // so we get error here.
-                if result == ptr::null_mut() {
-                    let errno = os::errno();
-                    Err(os::error_string(errno))
-                } else {
-                    Ok(result as *mut u8)
-                }
-            }
-            None => {
-                let mut handle = ptr::null_mut();
-                let succeeded = unsafe {
-                    GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &mut handle)
-                };
-                if succeeded == libc::FALSE {
-                    let errno = os::errno();
-                    Err(os::error_string(errno))
-                } else {
-                    Ok(handle as *mut u8)
-                }
-            }
-        };
 
-        unsafe {
-            if use_thread_mode {
-                SetThreadErrorMode(prev_error_mode, ptr::null_mut());
-            } else {
-                SetErrorMode(prev_error_mode);
-            }
-        }
+    pub unsafe fn open_external(filename: &[u8]) -> *mut u8 {
+        // Windows expects Unicode data
+        let filename_str = str::from_utf8(filename).unwrap();
+        let mut filename_str: Vec<u16> = filename_str.utf16_units().collect();
+        filename_str.push(0);
+        LoadLibraryW(filename_str.as_ptr() as *const libc::c_void) as *mut u8
+    }
 
-        result
+    pub unsafe fn open_internal() -> *mut u8 {
+        let mut handle = ptr::null_mut();
+        GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &mut handle);
+        handle as *mut u8
     }
 
     pub fn check_for_errors_in<T, F>(f: F) -> Result<T, String> where
@@ -381,10 +326,10 @@ mod dl {
         fn SetLastError(error: libc::size_t);
         fn LoadLibraryW(name: *const libc::c_void) -> *mut libc::c_void;
         fn GetModuleHandleExW(dwFlags: libc::DWORD, name: *const u16,
-                              handle: *mut *mut libc::c_void) -> libc::BOOL;
+                              handle: *mut *mut libc::c_void)
+                              -> *mut libc::c_void;
         fn GetProcAddress(handle: *mut libc::c_void,
                           name: *const libc::c_char) -> *mut libc::c_void;
         fn FreeLibrary(handle: *mut libc::c_void);
-        fn SetErrorMode(uMode: libc::c_uint) -> libc::c_uint;
     }
 }

trunk/src/libstd/sys/windows/c.rs

@@ -226,7 +226,6 @@ pub mod compat {
     /// * `CreateSymbolicLinkW`: Windows XP, Windows Server 2003
     /// * `GetFinalPathNameByHandleW`: Windows XP, Windows Server 2003
     pub mod kernel32 {
-        use libc::c_uint;
         use libc::types::os::arch::extra::{DWORD, LPCWSTR, BOOLEAN, HANDLE};
         use libc::consts::os::extra::ERROR_CALL_NOT_IMPLEMENTED;
 
@@ -250,12 +249,6 @@ pub mod compat {
                 unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
             }
         }
-
-        compat_fn! {
-            kernel32::SetThreadErrorMode(_dwNewMode: DWORD, _lpOldMode: *mut DWORD) -> c_uint {
-                unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
-            }
-        }
     }
 }