rollup merge of #21444: petrochenkov/null

Conflicts:
	src/libstd/sync/mpsc/select.rs

Author: alexcrichton

src/liballoc/heap.rs

@@ -280,7 +280,7 @@ mod imp {
         if align <= MIN_ALIGN {
             libc::malloc(size as libc::size_t) as *mut u8
         } else {
-            let mut out = 0 as *mut libc::c_void;
+            let mut out = ptr::null();
             let ret = posix_memalign(&mut out,
                                      align as libc::size_t,
                                      size as libc::size_t);

src/liblog/lib.rs

@@ -180,6 +180,7 @@ use std::io::LineBufferedWriter;
 use std::io;
 use std::mem;
 use std::os;
+use std::ptr;
 use std::rt;
 use std::slice;
 use std::sync::{Once, ONCE_INIT};
@@ -437,11 +438,11 @@ fn init() {
             assert!(!DIRECTIVES.is_null());
             let _directives: Box<Vec<directive::LogDirective>> =
                 mem::transmute(DIRECTIVES);
-            DIRECTIVES = 0 as *const Vec<directive::LogDirective>;
+            DIRECTIVES = ptr::null();
 
             if !FILTER.is_null() {
                 let _filter: Box<Regex> = mem::transmute(FILTER);
-                FILTER = 0 as *const _;
+                FILTER = ptr::null();
             }
         });
     }

src/librustc_llvm/diagnostic.rs

@@ -14,6 +14,7 @@ pub use self::OptimizationDiagnosticKind::*;
 pub use self::Diagnostic::*;
 
 use libc::c_char;
+use std::ptr;
 
 use {ValueRef, TwineRef, DebugLocRef, DiagnosticInfoRef};
 
@@ -52,10 +53,10 @@ impl OptimizationDiagnostic {
 
         let mut opt = OptimizationDiagnostic {
             kind: kind,
-            pass_name: 0 as *const c_char,
-            function: 0 as ValueRef,
-            debug_loc: 0 as DebugLocRef,
-            message: 0 as TwineRef,
+            pass_name: ptr::null(),
+            function: ptr::null_mut(),
+            debug_loc: ptr::null_mut(),
+            message: ptr::null_mut(),
         };
 
         super::LLVMUnpackOptimizationDiagnostic(di,

src/librustc_llvm/lib.rs

@@ -53,7 +53,7 @@ pub use self::Linkage::*;
 
 use std::ffi::CString;
 use std::cell::RefCell;
-use std::{raw, mem};
+use std::{raw, mem, ptr};
 use libc::{c_uint, c_ushort, uint64_t, c_int, size_t, c_char};
 use libc::{c_longlong, c_ulonglong, c_void};
 use debuginfo::{DIBuilderRef, DIDescriptor,
@@ -2262,19 +2262,18 @@ pub unsafe fn static_link_hack_this_sucks() {
     LLVMInitializePowerPCAsmPrinter();
     LLVMInitializePowerPCAsmParser();
 
-    LLVMRustSetLLVMOptions(0 as c_int,
-                                       0 as *const _);
+    LLVMRustSetLLVMOptions(0 as c_int, ptr::null());
 
-    LLVMPassManagerBuilderPopulateModulePassManager(0 as *mut _, 0 as *mut _);
-    LLVMPassManagerBuilderPopulateLTOPassManager(0 as *mut _, 0 as *mut _, False, False);
-    LLVMPassManagerBuilderPopulateFunctionPassManager(0 as *mut _, 0 as *mut _);
-    LLVMPassManagerBuilderSetOptLevel(0 as *mut _, 0 as c_uint);
-    LLVMPassManagerBuilderUseInlinerWithThreshold(0 as *mut _, 0 as c_uint);
-    LLVMWriteBitcodeToFile(0 as *mut _, 0 as *const _);
+    LLVMPassManagerBuilderPopulateModulePassManager(ptr::null_mut(), ptr::null_mut());
+    LLVMPassManagerBuilderPopulateLTOPassManager(ptr::null_mut(), ptr::null_mut(), False, False);
+    LLVMPassManagerBuilderPopulateFunctionPassManager(ptr::null_mut(), ptr::null_mut());
+    LLVMPassManagerBuilderSetOptLevel(ptr::null_mut(), 0 as c_uint);
+    LLVMPassManagerBuilderUseInlinerWithThreshold(ptr::null_mut(), 0 as c_uint);
+    LLVMWriteBitcodeToFile(ptr::null_mut(), ptr::null());
     LLVMPassManagerBuilderCreate();
-    LLVMPassManagerBuilderDispose(0 as *mut _);
+    LLVMPassManagerBuilderDispose(ptr::null_mut());
 
-    LLVMRustLinkInExternalBitcode(0 as *mut _, 0 as *const _, 0 as size_t);
+    LLVMRustLinkInExternalBitcode(ptr::null_mut(), ptr::null(), 0 as size_t);
 
     LLVMLinkInMCJIT();
     LLVMLinkInInterpreter();

src/librustc_trans/trans/type_.rs

@@ -21,6 +21,7 @@ use syntax::ast;
 
 use std::ffi::CString;
 use std::mem;
+use std::ptr;
 use std::cell::RefCell;
 use std::iter::repeat;
 
@@ -295,7 +296,7 @@ impl Type {
             if n_elts == 0 {
                 return Vec::new();
             }
-            let mut elts: Vec<_> = repeat(Type { rf: 0 as TypeRef }).take(n_elts).collect();
+            let mut elts: Vec<_> = repeat(Type { rf: ptr::null_mut() }).take(n_elts).collect();
             llvm::LLVMGetStructElementTypes(self.to_ref(),
                                             elts.as_mut_ptr() as *mut TypeRef);
             elts
@@ -309,7 +310,7 @@ impl Type {
     pub fn func_params(&self) -> Vec<Type> {
         unsafe {
             let n_args = llvm::LLVMCountParamTypes(self.to_ref()) as uint;
-            let mut args: Vec<_> = repeat(Type { rf: 0 as TypeRef }).take(n_args).collect();
+            let mut args: Vec<_> = repeat(Type { rf: ptr::null_mut() }).take(n_args).collect();
             llvm::LLVMGetParamTypes(self.to_ref(),
                                     args.as_mut_ptr() as *mut TypeRef);
             args

src/libstd/io/stdio.rs

@@ -40,6 +40,7 @@ use mem;
 use option::Option;
 use option::Option::{Some, None};
 use ops::{Deref, DerefMut, FnOnce};
+use ptr;
 use result::Result::{Ok, Err};
 use rt;
 use slice::SliceExt;
@@ -238,7 +239,7 @@ pub fn stdin() -> StdinReader {
             // Make sure to free it at exit
             rt::at_exit(|| {
                 mem::transmute::<_, Box<StdinReader>>(STDIN);
-                STDIN = 0 as *const _;
+                STDIN = ptr::null();
             });
         });
 

src/libstd/sync/mpsc/mpsc_queue.rs

@@ -46,6 +46,7 @@ use core::prelude::*;
 
 use alloc::boxed::Box;
 use core::mem;
+use core::ptr;
 use core::cell::UnsafeCell;
 
 use sync::atomic::{AtomicPtr, Ordering};
@@ -82,7 +83,7 @@ unsafe impl<T:Send> Sync for Queue<T> { }
 impl<T> Node<T> {
     unsafe fn new(v: Option<T>) -> *mut Node<T> {
         mem::transmute(box Node {
-            next: AtomicPtr::new(0 as *mut Node<T>),
+            next: AtomicPtr::new(ptr::null_mut()),
             value: v,
         })
     }

src/libstd/sync/mpsc/select.rs

@@ -59,6 +59,7 @@ use core::prelude::*;
 use core::cell::Cell;
 use core::marker;
 use core::mem;
+use core::ptr;
 use core::uint;
 
 use sync::mpsc::{Receiver, RecvError};
@@ -109,16 +110,15 @@ pub trait Packet {
 }
 
 impl Select {
-
     /// Creates a new selection structure. This set is initially empty and
     /// `wait` will panic!() if called.
     ///
     /// Usage of this struct directly can sometimes be burdensome, and usage is
     /// rather much easier through the `select!` macro.
     pub fn new() -> Select {
         Select {
-            head: 0 as *mut Handle<'static, ()>,
-            tail: 0 as *mut Handle<'static, ()>,
+            head: ptr::null_mut(),
+            tail: ptr::null_mut(),
             next_id: Cell::new(1),
         }
     }
@@ -132,8 +132,8 @@ impl Select {
         Handle {
             id: id,
             selector: self,
-            next: 0 as *mut Handle<'static, ()>,
-            prev: 0 as *mut Handle<'static, ()>,
+            next: ptr::null_mut(),
+            prev: ptr::null_mut(),
             added: false,
             rx: rx,
             packet: rx,
@@ -298,8 +298,8 @@ impl<'rx, T: Send> Handle<'rx, T> {
             (*self.next).prev = self.prev;
         }
 
-        self.next = 0 as *mut Handle<'static, ()>;
-        self.prev = 0 as *mut Handle<'static, ()>;
+        self.next = ptr::null_mut();
+        self.prev = ptr::null_mut();
 
         self.added = false;
     }

src/libstd/sync/mpsc/spsc_queue.rs

@@ -39,6 +39,7 @@ use core::prelude::*;
 
 use alloc::boxed::Box;
 use core::mem;
+use core::ptr;
 use core::cell::UnsafeCell;
 
 use sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
@@ -82,7 +83,7 @@ impl<T: Send> Node<T> {
         unsafe {
             mem::transmute(box Node {
                 value: None,
-                next: AtomicPtr::new(0 as *mut Node<T>),
+                next: AtomicPtr::new(ptr::null_mut::<Node<T>>()),
             })
         }
     }
@@ -131,7 +132,7 @@ impl<T: Send> Queue<T> {
             let n = self.alloc();
             assert!((*n).value.is_none());
             (*n).value = Some(t);
-            (*n).next.store(0 as *mut Node<T>, Ordering::Relaxed);
+            (*n).next.store(ptr::null_mut(), Ordering::Relaxed);
             (**self.head.get()).next.store(n, Ordering::Release);
             *self.head.get() = n;
         }

src/libstd/sync/mpsc/sync.rs

@@ -40,6 +40,7 @@ use self::Blocker::*;
 
 use vec::Vec;
 use core::mem;
+use core::ptr;
 
 use sync::atomic::{Ordering, AtomicUsize};
 use sync::mpsc::blocking::{self, WaitToken, SignalToken};
@@ -145,8 +146,8 @@ impl<T: Send> Packet<T> {
                 cap: cap,
                 canceled: None,
                 queue: Queue {
-                    head: 0 as *mut Node,
-                    tail: 0 as *mut Node,
+                    head: ptr::null_mut(),
+                    tail: ptr::null_mut(),
                 },
                 buf: Buffer {
                     buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
@@ -160,7 +161,7 @@ impl<T: Send> Packet<T> {
     // wait until a send slot is available, returning locked access to
     // the channel state.
     fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
-        let mut node = Node { token: None, next: 0 as *mut Node };
+        let mut node = Node { token: None, next: ptr::null_mut() };
         loop {
             let mut guard = self.lock.lock().unwrap();
             // are we ready to go?
@@ -343,8 +344,8 @@ impl<T: Send> Packet<T> {
             Vec::new()
         };
         let mut queue = mem::replace(&mut guard.queue, Queue {
-            head: 0 as *mut Node,
-            tail: 0 as *mut Node,
+            head: ptr::null_mut(),
+            tail: ptr::null_mut(),
         });
 
         let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
@@ -453,7 +454,7 @@ impl Queue {
     fn enqueue(&mut self, node: &mut Node) -> WaitToken {
         let (wait_token, signal_token) = blocking::tokens();
         node.token = Some(signal_token);
-        node.next = 0 as *mut Node;
+        node.next = ptr::null_mut();
 
         if self.tail.is_null() {
             self.head = node as *mut Node;
@@ -475,10 +476,10 @@ impl Queue {
         let node = self.head;
         self.head = unsafe { (*node).next };
         if self.head.is_null() {
-            self.tail = 0 as *mut Node;
+            self.tail = ptr::null_mut();
         }
         unsafe {
-            (*node).next = 0 as *mut Node;
+            (*node).next = ptr::null_mut();
             Some((*node).token.take().unwrap())
         }
     }