librustc: Make extern functions no longer of *u8 type.

Calling them LLVM asserts still, but that never worked anyway. This
is the backwards compatible part.

Author: pcwalton

src/libcore/rt/context.rs

@@ -45,7 +45,7 @@ pub impl Context {
         // The C-ABI function that is the task entry point
         extern fn task_start_wrapper(f: &~fn()) { (*f)() }
 
-        let fp: *c_void = task_start_wrapper as *c_void;
+        let fp: *c_void = unsafe { transmute(task_start_wrapper) };
         let argp: *c_void = unsafe { transmute::<&~fn(), *c_void>(&*start) };
         let sp: *uint = stack.end();
         let sp: *mut uint = unsafe { transmute_mut_unsafe(sp) };

src/libcore/rt/local_services.rs

@@ -138,7 +138,14 @@ impl Unwinder {
 
         extern {
             #[rust_stack]
+            #[cfg(stage0)]
             fn rust_try(f: *u8, code: *c_void, data: *c_void) -> uintptr_t;
+            #[rust_stack]
+            #[cfg(not(stage0))]
+            fn rust_try(f: extern "C" fn(code: *c_void, env: *c_void),
+                        code: *c_void,
+                        data: *c_void)
+                        -> uintptr_t;
         }
     }
 

src/libcore/rt/uv/net.rs

@@ -62,15 +62,16 @@ pub type AllocCallback = ~fn(uint) -> Buf;
 impl Callback for AllocCallback { }
 
 pub impl StreamWatcher {
-
     fn read_start(&mut self, alloc: AllocCallback, cb: ReadCallback) {
         // XXX: Borrowchk problems
         let data = get_watcher_data(unsafe { transmute_mut_region(self) });
         data.alloc_cb = Some(alloc);
         data.read_cb = Some(cb);
 
         let handle = self.native_handle();
-        unsafe { uvll::read_start(handle, alloc_cb, read_cb); }
+        unsafe {
+            uvll::read_start(handle, alloc_cb, read_cb);
+        }
 
         extern fn alloc_cb(stream: *uvll::uv_stream_t, suggested_size: size_t) -> Buf {
             let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
@@ -112,8 +113,9 @@ pub impl StreamWatcher {
         let bufs = [buf];
         unsafe {
             assert!(0 == uvll::write(req.native_handle(),
-                                          self.native_handle(),
-                                          bufs, write_cb));
+                                     self.native_handle(),
+                                     bufs,
+                                     write_cb));
         }
 
         extern fn write_cb(req: *uvll::uv_write_t, status: c_int) {
@@ -147,7 +149,9 @@ pub impl StreamWatcher {
             data.close_cb = Some(cb);
         }
 
-        unsafe { uvll::close(self.native_handle(), close_cb); }
+        unsafe {
+            uvll::close(self.native_handle(), close_cb);
+        }
 
         extern fn close_cb(handle: *uvll::uv_stream_t) {
             let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
@@ -219,8 +223,9 @@ pub impl TcpWatcher {
                     do ip4_as_uv_ip4(address) |addr| {
                         rtdebug!("connect_t: %x", connect_handle as uint);
                         assert!(0 == uvll::tcp_connect(connect_handle,
-                                                            self.native_handle(),
-                                                            addr, connect_cb));
+                                                       self.native_handle(),
+                                                       addr,
+                                                       connect_cb));
                     }
                 }
                 _ => fail!()
@@ -251,7 +256,8 @@ pub impl TcpWatcher {
             static BACKLOG: c_int = 128; // XXX should be configurable
             // XXX: This can probably fail
             assert!(0 == uvll::listen(self.native_handle(),
-                                           BACKLOG, connection_cb));
+                                      BACKLOG,
+                                      connection_cb));
         }
 
         extern fn connection_cb(handle: *uvll::uv_stream_t, status: c_int) {

src/libcore/rt/uvll.rs

@@ -54,7 +54,10 @@ pub type uv_timer_t = c_void;
 pub type uv_stream_t = c_void;
 pub type uv_fs_t = c_void;
 
+#[cfg(stage0)]
 pub type uv_idle_cb = *u8;
+#[cfg(not(stage0))]
+pub type uv_idle_cb = extern "C" fn(*c_void, i32);
 
 pub type sockaddr_in = c_void;
 pub type sockaddr_in6 = c_void;
@@ -146,10 +149,17 @@ pub unsafe fn run(loop_handle: *c_void) {
     rust_uv_run(loop_handle);
 }
 
+#[cfg(stage0)]
 pub unsafe fn close<T>(handle: *T, cb: *u8) {
     rust_uv_close(handle as *c_void, cb);
 }
 
+#[cfg(not(stage0))]
+pub unsafe fn close<T>(handle: *T,
+                       callback: extern "C" fn(handle: *uv_stream_t)) {
+    rust_uv_close(handle as *c_void, callback);
+}
+
 pub unsafe fn walk(loop_handle: *c_void, cb: *u8, arg: *c_void) {
     rust_uv_walk(loop_handle, cb, arg);
 }
@@ -179,12 +189,29 @@ pub unsafe fn tcp_init(loop_handle: *c_void, handle: *uv_tcp_t) -> c_int {
 }
 
 // FIXME ref #2064
+#[cfg(stage0)]
+pub unsafe fn tcp_connect(connect_ptr: *uv_connect_t,
+                          tcp_handle_ptr: *uv_tcp_t,
+                          addr_ptr: *sockaddr_in,
+                          after_connect_cb: *u8)
+                          -> c_int {
+    return rust_uv_tcp_connect(connect_ptr,
+                               tcp_handle_ptr,
+                               after_connect_cb,
+                               addr_ptr);
+}
+
+// FIXME ref #2064
+#[cfg(not(stage0))]
 pub unsafe fn tcp_connect(connect_ptr: *uv_connect_t,
                           tcp_handle_ptr: *uv_tcp_t,
                           addr_ptr: *sockaddr_in,
-                          after_connect_cb: *u8) -> c_int {
-    return rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr,
-                                       after_connect_cb, addr_ptr);
+                          after_connect_cb: extern "C" fn(*c_void, i32))
+                          -> c_int {
+    return rust_uv_tcp_connect(connect_ptr,
+                               tcp_handle_ptr,
+                               after_connect_cb,
+                               addr_ptr);
 }
 // FIXME ref #2064
 pub unsafe fn tcp_connect6(connect_ptr: *uv_connect_t,
@@ -211,20 +238,64 @@ pub unsafe fn tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_in6) -
     return rust_uv_tcp_getpeername6(tcp_handle_ptr, name);
 }
 
+#[cfg(stage0)]
 pub unsafe fn listen<T>(stream: *T, backlog: c_int, cb: *u8) -> c_int {
     return rust_uv_listen(stream as *c_void, backlog, cb);
 }
 
+#[cfg(not(stage0))]
+pub unsafe fn listen<T>(stream: *T,
+                        backlog: c_int,
+                        callback: extern "C" fn(a: *c_void, b: i32))
+                        -> c_int {
+    return rust_uv_listen(stream as *c_void, backlog, callback);
+}
+
 pub unsafe fn accept(server: *c_void, client: *c_void) -> c_int {
     return rust_uv_accept(server as *c_void, client as *c_void);
 }
 
-pub unsafe fn write<T>(req: *uv_write_t, stream: *T, buf_in: &[uv_buf_t], cb: *u8) -> c_int {
+#[cfg(stage0)]
+pub unsafe fn write<T>(req: *uv_write_t,
+                       stream: *T,
+                       buf_in: &[uv_buf_t],
+                       callback: *u8)
+                       -> c_int {
+    let buf_ptr = vec::raw::to_ptr(buf_in);
+    let buf_cnt = vec::len(buf_in) as i32;
+    return rust_uv_write(req as *c_void,
+                         stream as *c_void,
+                         buf_ptr,
+                         buf_cnt,
+                         callback);
+}
+
+#[cfg(not(stage0))]
+pub unsafe fn write<T>(req: *uv_write_t,
+                       stream: *T,
+                       buf_in: &[uv_buf_t],
+                       callback: extern "C" fn(*c_void, i32))
+                       -> c_int {
     let buf_ptr = vec::raw::to_ptr(buf_in);
     let buf_cnt = vec::len(buf_in) as i32;
-    return rust_uv_write(req as *c_void, stream as *c_void, buf_ptr, buf_cnt, cb);
+    return rust_uv_write(req as *c_void,
+                         stream as *c_void,
+                         buf_ptr,
+                         buf_cnt,
+                         callback);
 }
-pub unsafe fn read_start(stream: *uv_stream_t, on_alloc: *u8, on_read: *u8) -> c_int {
+
+#[cfg(stage0)]
+pub unsafe fn read_start(stream: *uv_stream_t, on_alloc: *u8, on_read: *u8)
+                         -> c_int {
+    return rust_uv_read_start(stream as *c_void, on_alloc, on_read);
+}
+
+#[cfg(not(stage0))]
+pub unsafe fn read_start(stream: *uv_stream_t,
+                         on_alloc: extern "C" fn(*c_void, u64) -> uv_buf_t,
+                         on_read: extern "C" fn(*c_void, i64, uv_buf_t))
+                         -> c_int {
     return rust_uv_read_start(stream as *c_void, on_alloc, on_read);
 }
 
@@ -361,7 +432,13 @@ extern {
     fn rust_uv_loop_new() -> *c_void;
     fn rust_uv_loop_delete(lp: *c_void);
     fn rust_uv_run(loop_handle: *c_void);
+
+    #[cfg(stage0)]
     fn rust_uv_close(handle: *c_void, cb: *u8);
+    #[cfg(not(stage0))]
+    fn rust_uv_close(handle: *c_void,
+                     callback: extern "C" fn(handle: *uv_stream_t));
+
     fn rust_uv_walk(loop_handle: *c_void, cb: *u8, arg: *c_void);
 
     fn rust_uv_idle_new() -> *uv_idle_t;
@@ -390,11 +467,19 @@ extern {
     fn rust_uv_ip6_name(src: *sockaddr_in6, dst: *u8, size: size_t) -> c_int;
     fn rust_uv_ip4_port(src: *sockaddr_in) -> c_uint;
     fn rust_uv_ip6_port(src: *sockaddr_in6) -> c_uint;
+
     // FIXME ref #2064
+    #[cfg(stage0)]
     fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t,
                            tcp_handle_ptr: *uv_tcp_t,
                            after_cb: *u8,
                            addr: *sockaddr_in) -> c_int;
+    #[cfg(not(stage0))]
+    fn rust_uv_tcp_connect(connect_ptr: *uv_connect_t,
+                           tcp_handle_ptr: *uv_tcp_t,
+                           after_cb: extern "C" fn(*libc::c_void, i32),
+                           addr: *sockaddr_in) -> c_int;
+
     // FIXME ref #2064
     fn rust_uv_tcp_bind(tcp_server: *uv_tcp_t, addr: *sockaddr_in) -> c_int;
     // FIXME ref #2064
@@ -408,16 +493,39 @@ extern {
                                name: *sockaddr_in) -> c_int;
     fn rust_uv_tcp_getpeername6(tcp_handle_ptr: *uv_tcp_t,
                                 name: *sockaddr_in6) ->c_int;
+
+    #[cfg(stage0)]
     fn rust_uv_listen(stream: *c_void, backlog: c_int, cb: *u8) -> c_int;
+    #[cfg(not(stage0))]
+    fn rust_uv_listen(stream: *c_void,
+                      backlog: c_int,
+                      callback: extern "C" fn(a: *c_void, b: i32))
+                      -> c_int;
+
     fn rust_uv_accept(server: *c_void, client: *c_void) -> c_int;
+
+    #[cfg(stage0)]
     fn rust_uv_write(req: *c_void,
                      stream: *c_void,
                      buf_in: *uv_buf_t,
                      buf_cnt: c_int,
                      cb: *u8) -> c_int;
+
+    #[cfg(not(stage0))]
+    fn rust_uv_write(req: *c_void,
+                     stream: *c_void,
+                     buf_in: *uv_buf_t,
+                     buf_cnt: c_int,
+                     callback: extern "C" fn(*c_void, i32))
+                     -> c_int;
+    #[cfg(stage0)]
+    fn rust_uv_read_start(stream: *c_void, on_alloc: *u8, on_read: *u8)
+                          -> c_int;
+    #[cfg(not(stage0))]
     fn rust_uv_read_start(stream: *c_void,
-                          on_alloc: *u8,
-                          on_read: *u8) -> c_int;
+                          on_alloc: extern "C" fn(*c_void, u64) -> uv_buf_t,
+                          on_read: extern "C" fn(*c_void, i64, uv_buf_t))
+                          -> c_int;
     fn rust_uv_read_stop(stream: *c_void) -> c_int;
     fn rust_uv_timer_init(loop_handle: *c_void,
                           timer_handle: *uv_timer_t) -> c_int;

src/libcore/task/local_data_priv.rs

@@ -61,7 +61,7 @@ impl Eq for @LocalData {
 // proper map.
 type TaskLocalElement = (*libc::c_void, *libc::c_void, @LocalData);
 // Has to be a pointer at outermost layer; the foreign call returns void *.
-type TaskLocalMap = @mut ~[Option<TaskLocalElement>];
+pub type TaskLocalMap = @mut ~[Option<TaskLocalElement>];
 
 fn cleanup_task_local_map(map_ptr: *libc::c_void) {
     unsafe {
@@ -82,7 +82,6 @@ unsafe fn get_local_map(handle: Handle) -> TaskLocalMap {
 }
 
 unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
-
     extern fn cleanup_task_local_map_extern_cb(map_ptr: *libc::c_void) {
         cleanup_task_local_map(map_ptr);
     }

src/libcore/task/rt.rs

@@ -17,6 +17,7 @@ The task interface to the runtime
 #[doc(hidden)]; // FIXME #3538
 
 use libc;
+use task::local_data_priv::TaskLocalMap;
 
 #[allow(non_camel_case_types)] // runtime type
 pub type sched_id = int;
@@ -67,5 +68,11 @@ pub extern {
     #[rust_stack]
     fn rust_set_task_local_data(task: *rust_task, map: *libc::c_void);
     #[rust_stack]
+    #[cfg(stage0)]
     fn rust_task_local_data_atexit(task: *rust_task, cleanup_fn: *u8);
+    #[rust_stack]
+    #[cfg(not(stage0))]
+    fn rust_task_local_data_atexit(
+        task: *rust_task,
+        cleanup_fn: extern "C" fn(a: *libc::c_void));
 }

src/librustc/middle/trans/expr.rs

@@ -1644,10 +1644,16 @@ fn trans_imm_cast(bcx: block, expr: @ast::expr,
                                               val_ty(lldiscrim_a),
                                               lldiscrim_a, true),
                     cast_float => SIToFP(bcx, lldiscrim_a, ll_t_out),
-                    _ => ccx.sess.bug(~"translating unsupported cast.")
+                    _ => {
+                        ccx.sess.span_bug(expr.span,
+                                          ~"translating unsupported cast.")
+                    }
                 }
             }
-            _ => ccx.sess.bug(~"translating unsupported cast.")
+            _ => {
+                ccx.sess.span_bug(expr.span,
+                                  ~"translating unsupported cast.")
+            }
         };
     return immediate_rvalue_bcx(bcx, newval, t_out);
 }

src/librustc/middle/ty.rs

@@ -1769,6 +1769,15 @@ pub fn type_is_unique(ty: t) -> bool {
     }
 }
 
+pub fn type_is_castable(ty: t) -> bool {
+    match get(ty).sty {
+        ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
+        ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) | ty_type |
+        ty_ptr(_) => true,
+        _ => false
+    }
+}
+
 /*
  A scalar type is one that denotes an atomic datum, with no sub-components.
  (A ty_ptr is scalar because it represents a non-managed pointer, so its