1 files changed, 10 insertions, 10 deletions
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 1d3767c9e33..67d5482898e 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -36,7 +36,7 @@ mod num;
 mod float;
 pub mod rt;
 
-#[experimental = "core and I/O reconciliation may alter this definition"]
+#[unstable = "core and I/O reconciliation may alter this definition"]
 /// The type returned by formatter methods.
 pub type Result = result::Result<(), Error>;
 
@@ -45,7 +45,7 @@ pub type Result = result::Result<(), Error>;
 /// This type does not support transmission of an error other than that an error
 /// occurred. Any extra information must be arranged to be transmitted through
 /// some other means.
-#[experimental = "core and I/O reconciliation may alter this definition"]
+#[unstable = "core and I/O reconciliation may alter this definition"]
 #[derive(Copy)]
 pub struct Error;
 
@@ -58,7 +58,7 @@ pub struct Error;
 /// This trait should generally not be implemented by consumers of the standard
 /// library. The `write!` macro accepts an instance of `io::Writer`, and the
 /// `io::Writer` trait is favored over implementing this trait.
-#[experimental = "waiting for core and I/O reconciliation"]
+#[unstable = "waiting for core and I/O reconciliation"]
 pub trait Writer {
     /// Writes a slice of bytes into this writer, returning whether the write
     /// succeeded.
@@ -123,7 +123,7 @@ enum Void {}
 /// family of functions. It contains a function to format the given value. At
 /// compile time it is ensured that the function and the value have the correct
 /// types, and then this struct is used to canonicalize arguments to one type.
-#[experimental = "implementation detail of the `format_args!` macro"]
+#[unstable = "implementation detail of the `format_args!` macro"]
 #[derive(Copy)]
 pub struct Argument<'a> {
     value: &'a Void,
@@ -162,7 +162,7 @@ impl<'a> Arguments<'a> {
     /// When using the format_args!() macro, this function is used to generate the
     /// Arguments structure.
     #[doc(hidden)] #[inline]
-    #[experimental = "implementation detail of the `format_args!` macro"]
+    #[unstable = "implementation detail of the `format_args!` macro"]
     pub fn new(pieces: &'a [&'a str],
                args: &'a [Argument<'a>]) -> Arguments<'a> {
         Arguments {
@@ -179,7 +179,7 @@ impl<'a> Arguments<'a> {
     /// created with `argumentuint`. However, failing to do so doesn't cause
     /// unsafety, but will ignore invalid .
     #[doc(hidden)] #[inline]
-    #[experimental = "implementation detail of the `format_args!` macro"]
+    #[unstable = "implementation detail of the `format_args!` macro"]
     pub fn with_placeholders(pieces: &'a [&'a str],
                              fmt: &'a [rt::Argument<'a>],
                              args: &'a [Argument<'a>]) -> Arguments<'a> {
@@ -301,7 +301,7 @@ pub trait UpperExp {
 ///
 ///   * output - the buffer to write output to
 ///   * args - the precompiled arguments generated by `format_args!`
-#[experimental = "libcore and I/O have yet to be reconciled, and this is an \
+#[unstable = "libcore and I/O have yet to be reconciled, and this is an \
                   implementation detail which should not otherwise be exported"]
 pub fn write(output: &mut Writer, args: Arguments) -> Result {
     let mut formatter = Formatter {
@@ -563,7 +563,7 @@ impl<'a> Formatter<'a> {
     }
 
     /// Flags for formatting (packed version of rt::Flag)
-    #[experimental = "return type may change and method was just created"]
+    #[unstable = "return type may change and method was just created"]
     pub fn flags(&self) -> uint { self.flags }
 
     /// Character used as 'fill' whenever there is alignment
@@ -592,7 +592,7 @@ impl Show for Error {
 /// This is a function which calls are emitted to by the compiler itself to
 /// create the Argument structures that are passed into the `format` function.
 #[doc(hidden)] #[inline]
-#[experimental = "implementation detail of the `format_args!` macro"]
+#[unstable = "implementation detail of the `format_args!` macro"]
 pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
                        t: &'a T) -> Argument<'a> {
     Argument::new(t, f)
@@ -601,7 +601,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
 /// When the compiler determines that the type of an argument *must* be a uint
 /// (such as for width and precision), then it invokes this method.
 #[doc(hidden)] #[inline]
-#[experimental = "implementation detail of the `format_args!` macro"]
+#[unstable = "implementation detail of the `format_args!` macro"]
 pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
     Argument::from_uint(s)
 }