From 0dfc90ab15475aa64bea393671463a8e9784ae3f Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 25 Jun 2014 12:47:34 -0700 Subject: Rename all raw pointers as necessary --- src/libstd/rt/backtrace.rs | 85 ++++++++++++++++++++++++---------------------- src/libstd/rt/mod.rs | 2 +- 2 files changed, 45 insertions(+), 42 deletions(-) (limited to 'src/libstd/rt') diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index e3652ffac6e..8f51e834c6a 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -261,7 +261,8 @@ mod imp { use slice::{MutableVector}; extern { - fn backtrace(buf: *mut *libc::c_void, sz: libc::c_int) -> libc::c_int; + fn backtrace(buf: *mut *const libc::c_void, + sz: libc::c_int) -> libc::c_int; } // while it doesn't requires lock for work as everything is @@ -273,7 +274,7 @@ mod imp { try!(writeln!(w, "stack backtrace:")); // 100 lines should be enough static SIZE: libc::c_int = 100; - let mut buf: [*libc::c_void, ..SIZE] = unsafe {mem::zeroed()}; + let mut buf: [*const libc::c_void, ..SIZE] = unsafe {mem::zeroed()}; let cnt = unsafe { backtrace(buf.as_mut_ptr(), SIZE) as uint}; // skipping the first one as it is write itself @@ -307,7 +308,7 @@ mod imp { let mut cx = Context { writer: w, last_error: None, idx: 0 }; return match unsafe { uw::_Unwind_Backtrace(trace_fn, - &mut cx as *mut Context as *libc::c_void) + &mut cx as *mut Context as *mut libc::c_void) } { uw::_URC_NO_REASON => { match cx.last_error { @@ -318,10 +319,10 @@ mod imp { _ => Ok(()), }; - extern fn trace_fn(ctx: *uw::_Unwind_Context, - arg: *libc::c_void) -> uw::_Unwind_Reason_Code { + extern fn trace_fn(ctx: *mut uw::_Unwind_Context, + arg: *mut libc::c_void) -> uw::_Unwind_Reason_Code { let cx: &mut Context = unsafe { mem::transmute(arg) }; - let ip = unsafe { uw::_Unwind_GetIP(ctx) as *libc::c_void }; + let ip = unsafe { uw::_Unwind_GetIP(ctx) as *mut libc::c_void }; // dladdr() on osx gets whiny when we use FindEnclosingFunction, and // it appears to work fine without it, so we only use // FindEnclosingFunction on non-osx platforms. In doing so, we get a @@ -365,22 +366,22 @@ mod imp { #[cfg(target_os = "macos")] #[cfg(target_os = "ios")] - fn print(w: &mut Writer, idx: int, addr: *libc::c_void) -> IoResult<()> { + fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> { use intrinsics; #[repr(C)] struct Dl_info { - dli_fname: *libc::c_char, - dli_fbase: *libc::c_void, - dli_sname: *libc::c_char, - dli_saddr: *libc::c_void, + dli_fname: *const libc::c_char, + dli_fbase: *mut libc::c_void, + dli_sname: *const libc::c_char, + dli_saddr: *mut libc::c_void, } extern { - fn dladdr(addr: *libc::c_void, + fn dladdr(addr: *const libc::c_void, info: *mut Dl_info) -> libc::c_int; } let mut info: Dl_info = unsafe { intrinsics::init() }; - if unsafe { dladdr(addr, &mut info) == 0 } { + if unsafe { dladdr(addr as *const libc::c_void, &mut info) == 0 } { output(w, idx,addr, None) } else { output(w, idx, addr, Some(unsafe { @@ -390,7 +391,7 @@ mod imp { } #[cfg(not(target_os = "macos"), not(target_os = "ios"))] - fn print(w: &mut Writer, idx: int, addr: *libc::c_void) -> IoResult<()> { + fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> { use collections::Collection; use iter::Iterator; use os; @@ -405,17 +406,17 @@ mod imp { type backtrace_syminfo_callback = extern "C" fn(data: *mut libc::c_void, pc: libc::uintptr_t, - symname: *libc::c_char, + symname: *const libc::c_char, symval: libc::uintptr_t, symsize: libc::uintptr_t); type backtrace_error_callback = extern "C" fn(data: *mut libc::c_void, - msg: *libc::c_char, + msg: *const libc::c_char, errnum: libc::c_int); enum backtrace_state {} #[link(name = "backtrace", kind = "static")] extern { - fn backtrace_create_state(filename: *libc::c_char, + fn backtrace_create_state(filename: *const libc::c_char, threaded: libc::c_int, error: backtrace_error_callback, data: *mut libc::c_void) @@ -431,16 +432,16 @@ mod imp { // helper callbacks //////////////////////////////////////////////////////////////////////// - extern fn error_cb(_data: *mut libc::c_void, _msg: *libc::c_char, + extern fn error_cb(_data: *mut libc::c_void, _msg: *const libc::c_char, _errnum: libc::c_int) { // do nothing for now } extern fn syminfo_cb(data: *mut libc::c_void, _pc: libc::uintptr_t, - symname: *libc::c_char, + symname: *const libc::c_char, _symval: libc::uintptr_t, _symsize: libc::uintptr_t) { - let slot = data as *mut *libc::c_char; + let slot = data as *mut *const libc::c_char; unsafe { *slot = symname; } } @@ -502,8 +503,8 @@ mod imp { if state.is_null() { return output(w, idx, addr, None) } - let mut data = 0 as *libc::c_char; - let data_addr = &mut data as *mut *libc::c_char; + let mut data = 0 as *const libc::c_char; + let data_addr = &mut data as *mut *const libc::c_char; let ret = unsafe { backtrace_syminfo(state, addr as libc::uintptr_t, syminfo_cb, error_cb, @@ -517,7 +518,7 @@ mod imp { } // Finally, after all that work above, we can emit a symbol. - fn output(w: &mut Writer, idx: int, addr: *libc::c_void, + fn output(w: &mut Writer, idx: int, addr: *mut libc::c_void, s: Option) -> IoResult<()> { try!(write!(w, " {:2}: {:2$} - ", idx, addr, super::HEX_WIDTH)); match s.as_ref().and_then(|c| c.as_str()) { @@ -557,23 +558,23 @@ mod imp { pub enum _Unwind_Context {} pub type _Unwind_Trace_Fn = - extern fn(ctx: *_Unwind_Context, - arg: *libc::c_void) -> _Unwind_Reason_Code; + extern fn(ctx: *mut _Unwind_Context, + arg: *mut libc::c_void) -> _Unwind_Reason_Code; extern { // No native _Unwind_Backtrace on iOS #[cfg(not(target_os = "ios", target_arch = "arm"))] pub fn _Unwind_Backtrace(trace: _Unwind_Trace_Fn, - trace_argument: *libc::c_void) + trace_argument: *mut libc::c_void) -> _Unwind_Reason_Code; #[cfg(not(target_os = "android"), not(target_os = "linux", target_arch = "arm"))] - pub fn _Unwind_GetIP(ctx: *_Unwind_Context) -> libc::uintptr_t; + pub fn _Unwind_GetIP(ctx: *mut _Unwind_Context) -> libc::uintptr_t; #[cfg(not(target_os = "android"), not(target_os = "linux", target_arch = "arm"))] - pub fn _Unwind_FindEnclosingFunction(pc: *libc::c_void) - -> *libc::c_void; + pub fn _Unwind_FindEnclosingFunction(pc: *mut libc::c_void) + -> *mut libc::c_void; } // On android, the function _Unwind_GetIP is a macro, and this is the @@ -581,7 +582,7 @@ mod imp { // header file with the definition of _Unwind_GetIP. #[cfg(target_os = "android")] #[cfg(target_os = "linux", target_arch = "arm")] - pub unsafe fn _Unwind_GetIP(ctx: *_Unwind_Context) -> libc::uintptr_t { + pub unsafe fn _Unwind_GetIP(ctx: *mut _Unwind_Context) -> libc::uintptr_t { #[repr(C)] enum _Unwind_VRS_Result { _UVRSR_OK = 0, @@ -608,7 +609,7 @@ mod imp { type _Unwind_Word = libc::c_uint; extern { - fn _Unwind_VRS_Get(ctx: *_Unwind_Context, + fn _Unwind_VRS_Get(ctx: *mut _Unwind_Context, klass: _Unwind_VRS_RegClass, word: _Unwind_Word, repr: _Unwind_VRS_DataRepresentation, @@ -627,8 +628,8 @@ mod imp { // a no-op #[cfg(target_os = "android")] #[cfg(target_os = "linux", target_arch = "arm")] - pub unsafe fn _Unwind_FindEnclosingFunction(pc: *libc::c_void) - -> *libc::c_void + pub unsafe fn _Unwind_FindEnclosingFunction(pc: *mut libc::c_void) + -> *mut libc::c_void { pc } @@ -677,7 +678,7 @@ mod imp { extern "system" fn(libc::HANDLE, u64, *mut u64, *mut SYMBOL_INFO) -> libc::BOOL; type SymInitializeFn = - extern "system" fn(libc::HANDLE, *libc::c_void, + extern "system" fn(libc::HANDLE, *mut libc::c_void, libc::BOOL) -> libc::BOOL; type SymCleanupFn = extern "system" fn(libc::HANDLE) -> libc::BOOL; @@ -685,8 +686,8 @@ mod imp { type StackWalk64Fn = extern "system" fn(libc::DWORD, libc::HANDLE, libc::HANDLE, *mut STACKFRAME64, *mut arch::CONTEXT, - *libc::c_void, *libc::c_void, - *libc::c_void, *libc::c_void) -> libc::BOOL; + *mut libc::c_void, *mut libc::c_void, + *mut libc::c_void, *mut libc::c_void) -> libc::BOOL; static MAX_SYM_NAME: uint = 2000; static IMAGE_FILE_MACHINE_I386: libc::DWORD = 0x014c; @@ -735,7 +736,7 @@ mod imp { AddrFrame: ADDRESS64, AddrStack: ADDRESS64, AddrBStore: ADDRESS64, - FuncTableEntry: *libc::c_void, + FuncTableEntry: *mut libc::c_void, Params: [u64, ..4], Far: libc::BOOL, Virtual: libc::BOOL, @@ -924,7 +925,7 @@ mod imp { macro_rules! sym( ($e:expr, $t:ident) => (unsafe { match lib.symbol($e) { - Ok(f) => mem::transmute::<*u8, $t>(f), + Ok(f) => mem::transmute::<*mut u8, $t>(f), Err(..) => return Ok(()) } }) ) @@ -944,7 +945,7 @@ mod imp { let image = arch::init_frame(&mut frame, &context); // Initialize this process's symbols - let ret = SymInitialize(process, 0 as *libc::c_void, libc::TRUE); + let ret = SymInitialize(process, 0 as *mut libc::c_void, libc::TRUE); if ret != libc::TRUE { return Ok(()) } let _c = Cleanup { handle: process, SymCleanup: SymCleanup }; @@ -952,8 +953,10 @@ mod imp { let mut i = 0i; try!(write!(w, "stack backtrace:\n")); while StackWalk64(image, process, thread, &mut frame, &mut context, - 0 as *libc::c_void, 0 as *libc::c_void, - 0 as *libc::c_void, 0 as *libc::c_void) == libc::TRUE{ + 0 as *mut libc::c_void, + 0 as *mut libc::c_void, + 0 as *mut libc::c_void, + 0 as *mut libc::c_void) == libc::TRUE{ let addr = frame.AddrPC.Offset; if addr == frame.AddrReturn.Offset || addr == 0 || frame.AddrReturn.Offset == 0 { break } diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 66e7059422b..19853138afd 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -79,7 +79,7 @@ mod util; /// the crate's logging flags, registering GC /// metadata, and storing the process arguments. #[allow(experimental)] -pub fn init(argc: int, argv: **u8) { +pub fn init(argc: int, argv: *const *const u8) { rustrt::init(argc, argv); unsafe { unwind::register(failure::on_fail); } } -- cgit 1.4.1-3-g733a5 From f7bb31a47a11ea85535024965432bcef90f407f7 Mon Sep 17 00:00:00 2001 From: Aaron Turon Date: Mon, 30 Jun 2014 17:22:40 -0700 Subject: libstd: set baseline stability levels. Earlier commits have established a baseline of `experimental` stability for all crates under the facade (so their contents are considered experimental within libstd). Since `experimental` is `allow` by default, we should use the same baseline stability for libstd itself. This commit adds `experimental` tags to all of the modules defined in `std`, and `unstable` to `std` itself. --- src/libstd/ascii.rs | 2 ++ src/libstd/bitflags.rs | 1 + src/libstd/c_vec.rs | 2 ++ src/libstd/collections/mod.rs | 2 ++ src/libstd/failure.rs | 2 ++ src/libstd/fmt.rs | 2 ++ src/libstd/from_str.rs | 2 ++ src/libstd/gc.rs | 1 + src/libstd/io/mod.rs | 1 + src/libstd/lib.rs | 1 + src/libstd/macros.rs | 1 + src/libstd/num/f32.rs | 1 + src/libstd/num/f64.rs | 1 + src/libstd/num/float_macros.rs | 1 + src/libstd/num/int_macros.rs | 1 + src/libstd/num/mod.rs | 1 + src/libstd/num/uint_macros.rs | 1 + src/libstd/os.rs | 2 ++ src/libstd/path/mod.rs | 2 ++ src/libstd/prelude.rs | 2 ++ src/libstd/rand/mod.rs | 2 ++ src/libstd/rt/mod.rs | 2 ++ src/libstd/rtdeps.rs | 2 ++ src/libstd/sync/mod.rs | 2 ++ src/libstd/task.rs | 2 ++ src/libstd/to_str.rs | 2 ++ 26 files changed, 41 insertions(+) (limited to 'src/libstd/rt') diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 2730d90f05f..fae1b933210 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -10,6 +10,8 @@ //! Operations on ASCII strings and characters +#![experimental] + use collections::Collection; use fmt; use iter::Iterator; diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 7d821983075..834d461f20b 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -105,6 +105,7 @@ //! - `insert`: inserts the specified flags in-place //! - `remove`: removes the specified flags in-place +#![experimental] #![macro_escape] #[macro_export] diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs index 1926d6b1b96..a7d697c8665 100644 --- a/src/libstd/c_vec.rs +++ b/src/libstd/c_vec.rs @@ -33,6 +33,8 @@ //! handled correctly, i.e. that allocated memory is eventually freed //! if necessary. +#![experimental] + use collections::Collection; use kinds::Send; use mem; diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 9e5288f9541..ccef1c0fd2a 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -12,6 +12,8 @@ * Collection types. */ +#![experimental] + pub use core_collections::{Collection, Mutable, Map, MutableMap}; pub use core_collections::{Set, MutableSet, Deque}; pub use core_collections::{Bitv, BitvSet, BTree, DList, EnumSet}; diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index d1552f0bd10..47ff85e2806 100644 --- a/src/libstd/failure.rs +++ b/src/libstd/failure.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![experimental] + use alloc::owned::Box; use any::{Any, AnyRefExt}; use fmt; diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index ef0c59268c3..5834e576b08 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -412,6 +412,8 @@ the `}` character is escaped with `}}`. */ +#![experimental] + use io::Writer; use io; use result::{Ok, Err}; diff --git a/src/libstd/from_str.rs b/src/libstd/from_str.rs index 642bec48b83..1ca72bca20b 100644 --- a/src/libstd/from_str.rs +++ b/src/libstd/from_str.rs @@ -10,6 +10,8 @@ //! The `FromStr` trait for types that can be created from strings +#![experimental] + use option::{Option, Some, None}; use string::String; use str::StrAllocating; diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs index 80f1cbe6cb2..47b7426633c 100644 --- a/src/libstd/gc.rs +++ b/src/libstd/gc.rs @@ -16,6 +16,7 @@ collector is task-local so `Gc` is not sendable. */ +#![experimental] #![allow(experimental)] use clone::Clone; diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 8014759c88a..1d339b03af6 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -216,6 +216,7 @@ responding to errors that may occur while attempting to read the numbers. */ +#![experimental] #![deny(unused_must_use)] use char::Char; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index f63e69f3cca..48ccd1aa22c 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -95,6 +95,7 @@ //! and `format!`, also available to all Rust code. #![crate_id = "std#0.11.0-pre"] +#![unstable] #![comment = "The Rust standard library"] #![license = "MIT/ASL2"] #![crate_type = "rlib"] diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 4db15d2cbbe..8b79af8c931 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -14,6 +14,7 @@ //! library. Each macro is available for use when linking against the standard //! library. +#![experimental] #![macro_escape] /// The entry point for failure of rust tasks. diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index bbf1458da21..2b2ffb9f4e2 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -10,6 +10,7 @@ //! Operations and constants for 32-bits floats (`f32` type) +#![experimental] #![allow(missing_doc)] #![allow(unsigned_negate)] #![doc(primitive = "f32")] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index cfa8534160b..e156d2ce553 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -10,6 +10,7 @@ //! Operations and constants for 64-bits floats (`f64` type) +#![experimental] #![allow(missing_doc)] #![doc(primitive = "f64")] diff --git a/src/libstd/num/float_macros.rs b/src/libstd/num/float_macros.rs index 3e403219a4f..519de85edde 100644 --- a/src/libstd/num/float_macros.rs +++ b/src/libstd/num/float_macros.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![experimental] #![macro_escape] #![doc(hidden)] diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 9b3c9d29cc7..a4200b55a59 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![experimental] #![macro_escape] #![doc(hidden)] diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 65056652e3f..27ee1e3ce3b 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -13,6 +13,7 @@ //! These are implemented for the primitive numeric types in `std::{u8, u16, //! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`. +#![experimental] #![allow(missing_doc)] use option::Option; diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 19e45b292fb..7f2efe034a2 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![experimental] #![macro_escape] #![doc(hidden)] #![allow(unsigned_negate)] diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 5201a811791..6674dd532ae 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -26,6 +26,8 @@ * to write OS-ignorant code by default. */ +#![experimental] + #![allow(missing_doc)] #![allow(non_snake_case_functions)] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 6d48122b186..7d814df8ebf 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -63,6 +63,8 @@ println!("path exists: {}", path.exists()); */ +#![experimental] + use collections::Collection; use c_str::CString; use clone::Clone; diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs index dfe6988624e..61e8b63af35 100644 --- a/src/libstd/prelude.rs +++ b/src/libstd/prelude.rs @@ -37,6 +37,8 @@ //! particularly useful standalone functions, like `from_str`, `range`, and //! `drop`, `spawn`, and `channel`. +#![experimental] + // Reexported core operators #[doc(no_inline)] pub use kinds::{Copy, Send, Sized, Share}; #[doc(no_inline)] pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not}; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index f48d487461e..0ffaadef0a1 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -73,6 +73,8 @@ println!("{}", tuple) ``` */ +#![experimental] + use cell::RefCell; use clone::Clone; use io::IoResult; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 19853138afd..4490977bde6 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -51,6 +51,8 @@ Several modules in `core` are clients of `rt`: */ +#![experimental] + // FIXME: this should not be here. #![allow(missing_doc)] diff --git a/src/libstd/rtdeps.rs b/src/libstd/rtdeps.rs index f8bfde52261..0ffac99775c 100644 --- a/src/libstd/rtdeps.rs +++ b/src/libstd/rtdeps.rs @@ -12,6 +12,8 @@ //! the standard library This varies per-platform, but these libraries are //! necessary for running libstd. +#![experimental] + // All platforms need to link to rustrt #[link(name = "rust_builtin", kind = "static")] extern {} diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs index 5f45ce25502..cc32818baa4 100644 --- a/src/libstd/sync/mod.rs +++ b/src/libstd/sync/mod.rs @@ -15,6 +15,8 @@ //! and/or blocking at all, but rather provide the necessary tools to build //! other types of concurrent primitives. +#![experimental] + pub use core_sync::{atomics, deque, mpmc_bounded_queue, mpsc_queue, spsc_queue}; pub use core_sync::{Arc, Weak, Mutex, MutexGuard, Condvar, Barrier}; pub use core_sync::{RWLock, RWLockReadGuard, RWLockWriteGuard}; diff --git a/src/libstd/task.rs b/src/libstd/task.rs index 6492717d3ec..c20cbea0ae7 100644 --- a/src/libstd/task.rs +++ b/src/libstd/task.rs @@ -91,6 +91,8 @@ //! # } //! ``` +#![experimental] + use any::Any; use comm::channel; use io::{Writer, stdio}; diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs index 5deb7f151bb..e51e2c4d9ce 100644 --- a/src/libstd/to_str.rs +++ b/src/libstd/to_str.rs @@ -14,6 +14,8 @@ The `ToStr` trait for converting to strings */ +#![experimental] + use fmt; use string::String; -- cgit 1.4.1-3-g733a5