fixing #9483, Remove #[abi = "foo"] attributes from codebase.

src/libextra/time.rs

@@ -19,8 +19,7 @@ static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 pub mod rustrt {
     use super::Tm;
 
-    #[abi = "cdecl"]
-    extern {
+    extern "cdecl" {
         pub fn get_time(sec: &mut i64, nsec: &mut i32);
         pub fn precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();

src/libextra/unicode.rs

@@ -162,8 +162,7 @@ pub mod icu {
 
         // #[link_name = "icuuc"]
         #[link_args = "-licuuc"]
-        #[abi = "cdecl"]
-        extern {
+        extern "cdecl" {
             pub fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
             pub fn u_isdigit(c: UChar32) -> UBool;
             pub fn u_islower(c: UChar32) -> UBool;

src/librustc/lib/llvm.rs

@@ -298,8 +298,7 @@ pub mod llvm {
 
     #[link_args = "-Lrustllvm -lrustllvm"]
     #[link_name = "rustllvm"]
-    #[abi = "cdecl"]
-    extern {
+    extern "cdecl" {
         /* Create and destroy contexts. */
         #[fast_ffi]
         pub fn LLVMContextCreate() -> ContextRef;

src/libstd/fmt/mod.rs

@@ -33,14 +33,14 @@ arguments directly while performing minimal allocations.
 
 Some examples of the `format!` extension are:
 
-```rust
+~~~{.rust}
 format!("Hello")                  // => ~"Hello"
 format!("Hello, {:s}!", "world")  // => ~"Hello, world!"
 format!("The number is {:d}", 1)  // => ~"The number is 1"
 format!("{:?}", ~[3, 4])          // => ~"~[3, 4]"
 format!("{value}", value=4)       // => ~"4"
 format!("{} {}", 1, 2)            // => ~"1 2"
- ```
+~~~
 
 From these, you can see that the first argument is a format string. It is
 required by the compiler for this to be a string literal; it cannot be a
@@ -67,9 +67,9 @@ function, but the `format!` macro is a syntax extension which allows it to
 leverage named parameters. Named parameters are listed at the end of the
 argument list and have the syntax:
 
- ```
+~~~
 identifier '=' expression
- ```
+~~~
 
 It is illegal to put positional parameters (those without names) after arguments
 which have names. Like positional parameters, it is illegal to provided named
@@ -84,9 +84,9 @@ and if all references to one argument do not provide a type, then the format `?`
 is used (the type's rust-representation is printed). For example, this is an
 invalid format string:
 
- ```
+~~~
 {0:d} {0:s}
- ```
+~~~
 
 Because the first argument is both referred to as an integer as well as a
 string.
@@ -100,9 +100,9 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
 illegal to reference an argument as such. For example, this is another invalid
 format string:
 
- ```
+~~~
 {:.*s} {0:u}
- ```
+~~~
 
 ### Formatting traits
 
@@ -134,9 +134,9 @@ is `?` which is defined for all types by default.
 When implementing a format trait for your own time, you will have to implement a
 method of the signature:
 
-```rust
+~~~{.rust}
 fn fmt(value: &T, f: &mut std::fmt::Formatter);
- ```
+~~~
 
 Your type will be passed by-reference in `value`, and then the function should
 emit output into the `f.buf` stream. It is up to each format trait
@@ -150,14 +150,14 @@ helper methods.
 There are a number of related macros in the `format!` family. The ones that are
 currently implemented are:
 
-```rust
+~~~{.rust}
 format!      // described above
 write!       // first argument is a &mut rt::io::Writer, the destination
 writeln!     // same as write but appends a newline
 print!       // the format string is printed to the standard output
 println!     // same as print but appends a newline
 format_args! // described below.
- ```
+~~~
 
 
 #### `write!`
@@ -167,23 +167,23 @@ specified stream. This is used to prevent intermediate allocations of format
 strings and instead directly write the output. Under the hood, this function is
 actually invoking the `write` function defined in this module. Example usage is:
 
-```rust
+~~~{.rust}
 use std::rt::io;
 
 let mut w = io::mem::MemWriter::new();
 write!(&mut w as &mut io::Writer, "Hello {}!", "world");
- ```
+~~~
 
 #### `print!`
 
 This and `println` emit their output to stdout. Similarly to the `write!` macro,
 the goal of these macros is to avoid intermediate allocations when printing
 output. Example usage is:
 
-```rust
+~~~{.rust}
 print!("Hello {}!", "world");
 println!("I have a newline {}", "character at the end");
- ```
+~~~
 
 #### `format_args!`
 This is a curious macro which is used to safely pass around
@@ -193,13 +193,13 @@ references information on the stack. Under the hood, all of
 the related macros are implemented in terms of this. First
 off, some example usage is:
 
-```rust
+~~~{.rust}
 use std::fmt;
 
 format_args!(fmt::format, "this returns {}", "~str");
 format_args!(|args| { fmt::write(my_writer, args) }, "some {}", "args");
 format_args!(my_fn, "format {}", "string");
- ```
+~~~
 
 The first argument of the `format_args!` macro is a function (or closure) which
 takes one argument of type `&fmt::Arguments`. This structure can then be
@@ -236,9 +236,9 @@ Furthermore, whenever a case is running, the special character `#` can be used
 to reference the string value of the argument which was selected upon. As an
 example:
 
-```rust
+~~~{.rust}
 format!("{0, select, other{#}}", "hello") // => ~"hello"
- ```
+~~~
 
 This example is the equivalent of `{0:s}` essentially.
 
@@ -247,9 +247,9 @@ This example is the equivalent of `{0:s}` essentially.
 The select method is a switch over a `&str` parameter, and the parameter *must*
 be of the type `&str`. An example of the syntax is:
 
- ```
+~~~
 {0, select, male{...} female{...} other{...}}
- ```
+~~~
 
 Breaking this down, the `0`-th argument is selected upon with the `select`
 method, and then a number of cases follow. Each case is preceded by an
@@ -266,9 +266,9 @@ The plural method is a switch statement over a `uint` parameter, and the
 parameter *must* be a `uint`. A plural method in its full glory can be specified
 as:
 
- ```
+~~~
 {0, plural, offset=1 =1{...} two{...} many{...} other{...}}
- ```
+~~~
 
 To break this down, the first `0` indicates that this method is selecting over
 the value of the first positional parameter to the format string. Next, the
@@ -294,7 +294,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
 meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
 actual grammar for the formatting syntax is:
 
- ```
+~~~
 format_string := <text> [ format <text> ] *
 format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
 argument := integer | identifier
@@ -315,7 +315,7 @@ plural := 'plural' ',' [ 'offset:' integer ] ( selector arm ) *
 selector := '=' integer | keyword
 keyword := 'zero' | 'one' | 'two' | 'few' | 'many' | 'other'
 arm := '{' format_string '}'
- ```
+~~~
 
 ## Formatting Parameters
 
@@ -516,11 +516,11 @@ pub trait Float { fn fmt(&Self, &mut Formatter); }
 ///
 /// # Example
 ///
-/// ```rust
+/// ~~~{.rust}
 /// use std::fmt;
 /// let w: &mut io::Writer = ...;
 /// format_args!(|args| { fmt::write(w, args) }, "Hello, {}!", "world");
-/// ```
+/// ~~~
 pub fn write(output: &mut io::Writer, args: &Arguments) {
     unsafe { write_unsafe(output, args.fmt, args.args) }
 }
@@ -581,11 +581,11 @@ pub unsafe fn write_unsafe(output: &mut io::Writer,
 ///
 /// # Example
 ///
-/// ```rust
+/// ~~~{.rust}
 /// use std::fmt;
 /// let s = format_args!(fmt::format, "Hello, {}!", "world");
 /// assert_eq!(s, "Hello, world!");
-/// ```
+/// ~~~
 pub fn format(args: &Arguments) -> ~str {
     unsafe { format_unsafe(args.fmt, args.args) }
 }

src/libstd/io.rs

@@ -76,9 +76,8 @@ pub type fd_t = c_int;
 pub mod rustrt {
     use libc;
 
-    #[abi = "cdecl"]
     #[link_name = "rustrt"]
-    extern {
+    extern "cdecl" {
         pub fn rust_get_stdin() -> *libc::FILE;
         pub fn rust_get_stdout() -> *libc::FILE;
         pub fn rust_get_stderr() -> *libc::FILE;