diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 69be33167040c..39dd313ae860e 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -2076,7 +2076,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { let result = match get(ty).sty { // Scalar and unique types are sendable, freezable, and durable ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) | - ty_bare_fn(_) | ty_ptr(_) | ty::ty_char => { + ty_bare_fn(_) | ty::ty_char => { TC::None } @@ -2096,6 +2096,10 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents { object_contents(cx, store, mutbl, bounds) } + ty_ptr(ref mt) => { + tc_ty(cx, mt.ty, cache).other_pointer(TC::None) + } + ty_rptr(r, ref mt) => { tc_ty(cx, mt.ty, cache).other_pointer( borrowed_contents(r, mt.mutbl)) diff --git a/src/librustuv/uvio.rs b/src/librustuv/uvio.rs index 8ea3e2ddcc67a..02abe86d285c3 100644 --- a/src/librustuv/uvio.rs +++ b/src/librustuv/uvio.rs @@ -1007,14 +1007,12 @@ fn read_stream(mut watcher: StreamWatcher, let result_cell = Cell::new_empty(); let result_cell_ptr: *Cell> = &result_cell; - let buf_ptr: *&mut [u8] = &buf; + let uv_buf = slice_to_uv_buf(buf); do scheduler.deschedule_running_task_and_then |_sched, task| { let task_cell = Cell::new(task); // XXX: We shouldn't reallocate these callbacks every // call to read - let alloc: AllocCallback = |_| unsafe { - slice_to_uv_buf(*buf_ptr) - }; + let alloc: AllocCallback = |_| uv_buf; do watcher.read_start(alloc) |mut watcher, nread, _buf, status| { // Stop reading so that no read callbacks are @@ -1262,11 +1260,10 @@ impl RtioUdpSocket for UvUdpSocket { do self.home_for_io_with_sched |self_, scheduler| { let result_cell = Cell::new_empty(); let result_cell_ptr: *Cell> = &result_cell; - - let buf_ptr: *&mut [u8] = &buf; + let uv_buf = slice_to_uv_buf(buf); do scheduler.deschedule_running_task_and_then |_, task| { let task_cell = Cell::new(task); - let alloc: AllocCallback = |_| unsafe { slice_to_uv_buf(*buf_ptr) }; + let alloc: AllocCallback = |_| uv_buf; do self_.watcher.recv_start(alloc) |mut watcher, nread, _buf, addr, flags, status| { let _ = flags; // /XXX add handling for partials? diff --git a/src/test/compile-fail/kindck-freeze.rs b/src/test/compile-fail/kindck-freeze.rs new file mode 100644 index 0000000000000..c83892e2a3b31 --- /dev/null +++ b/src/test/compile-fail/kindck-freeze.rs @@ -0,0 +1,56 @@ +// Copyright 2012 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test which of the builtin types are considered freezeable. + +fn assert_freeze() { } +trait Dummy { } + +fn test<'a,T,U:Freeze>(_: &'a int) { + // lifetime pointers are ok... + assert_freeze::<&'static int>(); + assert_freeze::<&'a int>(); + assert_freeze::<&'a str>(); + assert_freeze::<&'a [int]>(); + + // ...unless they are mutable + assert_freeze::<&'static mut int>(); //~ ERROR does not fulfill `Freeze` + assert_freeze::<&'a mut int>(); //~ ERROR does not fulfill `Freeze` + + // ~ pointers are ok + assert_freeze::<~int>(); + assert_freeze::<~str>(); + assert_freeze::<~[int]>(); + + // but not if they own a bad thing + assert_freeze::<~&'a mut int>(); //~ ERROR does not fulfill `Freeze` + + // careful with object types, who knows what they close over... + assert_freeze::<&'a Dummy>(); //~ ERROR does not fulfill `Freeze` + assert_freeze::<~Dummy>(); //~ ERROR does not fulfill `Freeze` + + // ...unless they are properly bounded + assert_freeze::<&'a Dummy:Freeze>(); + assert_freeze::<&'static Dummy:Freeze>(); + assert_freeze::<~Dummy:Freeze>(); + + // ...but even then the pointer overrides + assert_freeze::<&'a mut Dummy:Freeze>(); //~ ERROR does not fulfill `Freeze` + + // closures are like an `&mut` object + assert_freeze::<&fn()>(); //~ ERROR does not fulfill `Freeze` + + // unsafe ptrs are ok unless they point at unfreezeable things + assert_freeze::<*int>(); + assert_freeze::<*&'a mut int>(); //~ ERROR does not fulfill `Freeze` +} + +fn main() { +} diff --git a/src/test/compile-fail/kindck-send.rs b/src/test/compile-fail/kindck-send.rs new file mode 100644 index 0000000000000..bb5851ac5c8f1 --- /dev/null +++ b/src/test/compile-fail/kindck-send.rs @@ -0,0 +1,59 @@ +// Copyright 2012 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test which of the builtin types are considered sendable. + +fn assert_send() { } +trait Dummy { } + +fn test<'a,T,U:Send>(_: &'a int) { + // lifetime pointers with 'static lifetime are ok + assert_send::<&'static int>(); + assert_send::<&'static str>(); + assert_send::<&'static [int]>(); + + // whether or not they are mutable + assert_send::<&'static mut int>(); + + // otherwise lifetime pointers are not ok + assert_send::<&'a int>(); //~ ERROR does not fulfill `Send` + assert_send::<&'a str>(); //~ ERROR does not fulfill `Send` + assert_send::<&'a [int]>(); //~ ERROR does not fulfill `Send` + + // ~ pointers are ok + assert_send::<~int>(); + assert_send::<~str>(); + assert_send::<~[int]>(); + + // but not if they own a bad thing + assert_send::<~&'a int>(); //~ ERROR does not fulfill `Send` + + // careful with object types, who knows what they close over... + assert_send::<&'static Dummy>(); //~ ERROR does not fulfill `Send` + assert_send::<&'a Dummy>(); //~ ERROR does not fulfill `Send` + assert_send::<&'a Dummy:Send>(); //~ ERROR does not fulfill `Send` + assert_send::<~Dummy:>(); //~ ERROR does not fulfill `Send` + + // ...unless they are properly bounded + assert_send::<&'static Dummy:Send>(); + assert_send::<~Dummy:Send>(); + + // but closure and object types can have lifetime bounds which make + // them not ok (FIXME #5121) + // assert_send::<~fn:'a()>(); // ERROR does not fulfill `Send` + // assert_send::<~Dummy:'a>(); // ERROR does not fulfill `Send` + + // unsafe ptrs are ok unless they point at unsendable things + assert_send::<*int>(); + assert_send::<*&'a int>(); //~ ERROR does not fulfill `Send` +} + +fn main() { +}