---

yaml
---
r: 59124
b: refs/heads/incoming
c: 56a1ee8
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 8d4d2b00c551301348cc09583498c02fdfbd64d7
+refs/heads/incoming: 56a1ee8f84e4aa2b9a45fe3fa7425ae8c8e6649a
 refs/heads/dist-snap: 00dbbd01c2aee72982b3e0f9511ae1d4428c3ba9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/doc/rust.md

@@ -618,7 +618,7 @@ each of which may have some number of [attributes](#attributes) attached to it.
 
 ~~~~~~~~ {.ebnf .gram}
 item : mod_item | fn_item | type_item | struct_item | enum_item
-     | static_item | trait_item | impl_item | foreign_mod_item ;
+     | static_item | trait_item | impl_item | extern_block ;
 ~~~~~~~~
 
 An _item_ is a component of a crate; some module items can be defined in crate
@@ -752,10 +752,11 @@ link_attr : ident '=' literal ;
 ~~~~~~~~
 
 An _`extern mod` declaration_ specifies a dependency on an external crate.
-The external crate is then bound into the declaring scope as the `ident` provided in the `extern_mod_decl`.
+The external crate is then bound into the declaring scope
+as the `ident` provided in the `extern_mod_decl`.
 
-The external crate is resolved to a specific `soname` at compile time, and a
-runtime linkage requirement to that `soname` is passed to the linker for
+The external crate is resolved to a specific `soname` at compile time,
+and a runtime linkage requirement to that `soname` is passed to the linker for
 loading at runtime. The `soname` is resolved at compile time by scanning the
 compiler's library path and matching the `link_attrs` provided in the
 `use_decl` against any `#link` attributes that were declared on the external
@@ -992,10 +993,10 @@ Thus the return type on `f` only needs to reflect the `if` branch of the conditi
 #### Extern functions
 
 Extern functions are part of Rust's foreign function interface,
-providing the opposite functionality to [foreign modules](#foreign-modules).
-Whereas foreign modules allow Rust code to call foreign code,
-extern functions with bodies defined in Rust code _can be called by foreign code_.
-They are defined in the same way as any other Rust function,
+providing the opposite functionality to [external blocks](#external-blocks).
+Whereas external blocks allow Rust code to call foreign code,
+extern functions with bodies defined in Rust code _can be called by foreign
+code_. They are defined in the same way as any other Rust function,
 except that they have the `extern` modifier.
 
 ~~~
@@ -1011,7 +1012,8 @@ let fptr: *u8 = new_vec;
 ~~~
 
 The primary motivation for extern functions is
-to create callbacks for foreign functions that expect to receive function pointers.
+to create callbacks for foreign functions that expect to receive function
+pointers.
 
 ### Type definitions
 
@@ -1308,64 +1310,61 @@ impl Seq<bool> for u32 {
 }
 ~~~~
 
-### Foreign modules
+### External blocks
 
 ~~~ {.ebnf .gram}
-foreign_mod_item : "extern mod" ident '{' foreign_mod '} ;
-foreign_mod : [ foreign_fn ] * ;
+extern_block_item : "extern" '{' extern_block '} ;
+extern_block : [ foreign_fn ] * ;
 ~~~
 
-Foreign modules form the basis for Rust's foreign function interface. A
-foreign module describes functions in external, non-Rust
-libraries.
-Functions within foreign modules are declared in the same way as other Rust functions,
-with the exception that they may not have a body and are instead terminated by a semicolon.
+External blocks form the basis for Rust's foreign function interface.
+Declarations in an external block describe symbols
+in external, non-Rust libraries.
+
+Functions within external blocks
+are declared in the same way as other Rust functions,
+with the exception that they may not have a body
+and are instead terminated by a semicolon.
 
 ~~~
 # use core::libc::{c_char, FILE};
 # #[nolink]
 
-extern mod c {
+extern {
     fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
 }
 ~~~
 
-Functions within foreign modules may be called by Rust code, just like functions defined in Rust.
-The Rust compiler automatically translates between the Rust ABI and the foreign ABI.
-
-The name of the foreign module has special meaning to the Rust compiler in
-that it will treat the module name as the name of a library to link to,
-performing the linking as appropriate for the target platform. The name
-given for the foreign module will be transformed in a platform-specific way
-to determine the name of the library. For example, on Linux the name of the
-foreign module is prefixed with 'lib' and suffixed with '.so', so the
-foreign mod 'rustrt' would be linked to a library named 'librustrt.so'.
+Functions within external blocks may be called by Rust code,
+just like functions defined in Rust.
+The Rust compiler automatically translates
+between the Rust ABI and the foreign ABI.
 
-A number of [attributes](#attributes) control the behavior of foreign
-modules.
+A number of [attributes](#attributes) control the behavior of external
+blocks.
 
-By default foreign modules assume that the library they are calling use the
-standard C "cdecl" ABI. Other ABIs may be specified using the `abi`
-attribute as in
+By default external blocks assume
+that the library they are calling uses the standard C "cdecl" ABI.
+Other ABIs may be specified using the `abi` attribute as in
 
 ~~~{.xfail-test}
 // Interface to the Windows API
 #[abi = "stdcall"]
-extern mod kernel32 { }
+extern { }
 ~~~
 
-The `link_name` attribute allows the default library naming behavior to
-be overridden by explicitly specifying the name of the library.
+The `link_name` attribute allows the name of the library to be specified.
 
 ~~~{.xfail-test}
 #[link_name = "crypto"]
-extern mod mycrypto { }
+extern { }
 ~~~
 
-The `nolink` attribute tells the Rust compiler not to do any linking for the foreign module.
-This is particularly useful for creating foreign
-modules for libc, which tends to not follow standard library naming
-conventions and is linked to all Rust programs anyway.
+The `nolink` attribute tells the Rust compiler
+not to do any linking for the external block.
+This is particularly useful for creating external blocks for libc,
+which tends to not follow standard library naming conventions
+and is linked to all Rust programs anyway.
 
 ## Attributes
 

branches/incoming/doc/tutorial-ffi.md

@@ -237,7 +237,8 @@ convention to use:
 ~~~~
 #[cfg(target_os = "win32")]
 #[abi = "stdcall"]
-extern mod kernel32 {
+#[link_name = "kernel32"]
+extern {
     fn SetEnvironmentVariableA(n: *u8, v: *u8) -> int;
 }
 ~~~~

branches/incoming/src/libcore/cell.rs

@@ -44,21 +44,21 @@ pub fn empty_cell<T>() -> Cell<T> {
 pub impl<T> Cell<T> {
     /// Yields the value, failing if the cell is empty.
     fn take(&self) -> T {
-        let self = unsafe { transmute_mut(self) };
-        if self.is_empty() {
+        let this = unsafe { transmute_mut(self) };
+        if this.is_empty() {
             fail!(~"attempt to take an empty cell");
         }
 
-        replace(&mut self.value, None).unwrap()
+        replace(&mut this.value, None).unwrap()
     }
 
     /// Returns the value, failing if the cell is full.
     fn put_back(&self, value: T) {
-        let self = unsafe { transmute_mut(self) };
-        if !self.is_empty() {
+        let this = unsafe { transmute_mut(self) };
+        if !this.is_empty() {
             fail!(~"attempt to put a value back into a full cell");
         }
-        self.value = Some(value);
+        this.value = Some(value);
     }
 
     /// Returns true if the cell is empty and false if the cell is full.

branches/incoming/src/libcore/num/f32.rs

@@ -450,58 +450,6 @@ impl Hyperbolic for f32 {
 
     #[inline(always)]
     fn tanh(&self) -> f32 { tanh(*self) }
-
-    ///
-    /// Inverse hyperbolic sine
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic sine of `self` will be returned
-    /// - `self` if `self` is `0.0`, `-0.0`, `infinity`, or `neg_infinity`
-    /// - `NaN` if `self` is `NaN`
-    ///
-    #[inline(always)]
-    fn asinh(&self) -> f32 {
-        match *self {
-            infinity     => infinity,
-            neg_infinity => neg_infinity,
-            x            => (x + ((x * x) + 1.0).sqrt()).ln(),
-        }
-    }
-
-    ///
-    /// Inverse hyperbolic cosine
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic cosine of `self` will be returned
-    /// - `infinity` if `self` is `infinity`
-    /// - `NaN` if `self` is `NaN` or `self < 1.0` (including `neg_infinity`)
-    ///
-    #[inline(always)]
-    fn acosh(&self) -> f32 {
-        match *self {
-            x if x < 1.0 => Float::NaN(),
-            x => (x + ((x * x) - 1.0).sqrt()).ln(),
-        }
-    }
-
-    ///
-    /// Inverse hyperbolic tangent
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic tangent of `self` will be returned
-    /// - `self` if `self` is `0.0` or `-0.0`
-    /// - `infinity` if `self` is `1.0`
-    /// - `neg_infinity` if `self` is `-1.0`
-    /// - `NaN` if the `self` is `NaN` or outside the domain of `-1.0 <= self <= 1.0`
-    ///   (including `infinity` and `neg_infinity`)
-    ///
-    #[inline(always)]
-    fn atanh(&self) -> f32 {
-        0.5 * ((2.0 * *self) / (1.0 - *self)).ln_1p()
-    }
 }
 
 impl Real for f32 {
@@ -1024,43 +972,6 @@ mod tests {
         assert_approx_eq!((-1.7f32).fract(), -0.7f32);
     }
 
-    #[test]
-    fn test_asinh() {
-        assert_eq!(0.0f32.asinh(), 0.0f32);
-        assert_eq!((-0.0f32).asinh(), -0.0f32);
-        assert_eq!(Float::infinity::<f32>().asinh(), Float::infinity::<f32>());
-        assert_eq!(Float::neg_infinity::<f32>().asinh(), Float::neg_infinity::<f32>());
-        assert!(Float::NaN::<f32>().asinh().is_NaN());
-        assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
-        assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32);
-    }
-
-    #[test]
-    fn test_acosh() {
-        assert_eq!(1.0f32.acosh(), 0.0f32);
-        assert!(0.999f32.acosh().is_NaN());
-        assert_eq!(Float::infinity::<f32>().acosh(), Float::infinity::<f32>());
-        assert!(Float::neg_infinity::<f32>().acosh().is_NaN());
-        assert!(Float::NaN::<f32>().acosh().is_NaN());
-        assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
-        assert_approx_eq!(3.0f32.acosh(), 1.76274717403908605046521864995958461f32);
-    }
-
-    #[test]
-    fn test_atanh() {
-        assert_eq!(0.0f32.atanh(), 0.0f32);
-        assert_eq!((-0.0f32).atanh(), -0.0f32);
-        assert_eq!(1.0f32.atanh(), Float::infinity::<f32>());
-        assert_eq!((-1.0f32).atanh(), Float::neg_infinity::<f32>());
-        assert!(2f64.atanh().atanh().is_NaN());
-        assert!((-2f64).atanh().atanh().is_NaN());
-        assert!(Float::infinity::<f64>().atanh().is_NaN());
-        assert!(Float::neg_infinity::<f64>().atanh().is_NaN());
-        assert!(Float::NaN::<f32>().atanh().is_NaN());
-        assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
-        assert_approx_eq!((-0.5f32).atanh(), -0.54930614433405484569762261846126285f32);
-    }
-
     #[test]
     fn test_real_consts() {
         assert_approx_eq!(Real::two_pi::<f32>(), 2f32 * Real::pi::<f32>());

branches/incoming/src/libcore/num/f64.rs

@@ -463,58 +463,6 @@ impl Hyperbolic for f64 {
 
     #[inline(always)]
     fn tanh(&self) -> f64 { tanh(*self) }
-
-    ///
-    /// Inverse hyperbolic sine
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic sine of `self` will be returned
-    /// - `self` if `self` is `0.0`, `-0.0`, `infinity`, or `neg_infinity`
-    /// - `NaN` if `self` is `NaN`
-    ///
-    #[inline(always)]
-    fn asinh(&self) -> f64 {
-        match *self {
-            infinity     => infinity,
-            neg_infinity => neg_infinity,
-            x            => (x + ((x * x) + 1.0).sqrt()).ln(),
-        }
-    }
-
-    ///
-    /// Inverse hyperbolic cosine
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic cosine of `self` will be returned
-    /// - `infinity` if `self` is `infinity`
-    /// - `NaN` if `self` is `NaN` or `self < 1.0` (including `neg_infinity`)
-    ///
-    #[inline(always)]
-    fn acosh(&self) -> f64 {
-        match *self {
-            x if x < 1.0 => Float::NaN(),
-            x => (x + ((x * x) - 1.0).sqrt()).ln(),
-        }
-    }
-
-    ///
-    /// Inverse hyperbolic tangent
-    ///
-    /// # Returns
-    ///
-    /// - on success, the inverse hyperbolic tangent of `self` will be returned
-    /// - `self` if `self` is `0.0` or `-0.0`
-    /// - `infinity` if `self` is `1.0`
-    /// - `neg_infinity` if `self` is `-1.0`
-    /// - `NaN` if the `self` is `NaN` or outside the domain of `-1.0 <= self <= 1.0`
-    ///   (including `infinity` and `neg_infinity`)
-    ///
-    #[inline(always)]
-    fn atanh(&self) -> f64 {
-        0.5 * ((2.0 * *self) / (1.0 - *self)).ln_1p()
-    }
 }
 
 impl Real for f64 {
@@ -1071,43 +1019,6 @@ mod tests {
         assert_approx_eq!((-1.7f64).fract(), -0.7f64);
     }
 
-    #[test]
-    fn test_asinh() {
-        assert_eq!(0.0f64.asinh(), 0.0f64);
-        assert_eq!((-0.0f64).asinh(), -0.0f64);
-        assert_eq!(Float::infinity::<f64>().asinh(), Float::infinity::<f64>());
-        assert_eq!(Float::neg_infinity::<f64>().asinh(), Float::neg_infinity::<f64>());
-        assert!(Float::NaN::<f64>().asinh().is_NaN());
-        assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64);
-        assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
-    }
-
-    #[test]
-    fn test_acosh() {
-        assert_eq!(1.0f64.acosh(), 0.0f64);
-        assert!(0.999f64.acosh().is_NaN());
-        assert_eq!(Float::infinity::<f64>().acosh(), Float::infinity::<f64>());
-        assert!(Float::neg_infinity::<f64>().acosh().is_NaN());
-        assert!(Float::NaN::<f64>().acosh().is_NaN());
-        assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64);
-        assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
-    }
-
-    #[test]
-    fn test_atanh() {
-        assert_eq!(0.0f64.atanh(), 0.0f64);
-        assert_eq!((-0.0f64).atanh(), -0.0f64);
-        assert_eq!(1.0f64.atanh(), Float::infinity::<f64>());
-        assert_eq!((-1.0f64).atanh(), Float::neg_infinity::<f64>());
-        assert!(2f64.atanh().atanh().is_NaN());
-        assert!((-2f64).atanh().atanh().is_NaN());
-        assert!(Float::infinity::<f64>().atanh().is_NaN());
-        assert!(Float::neg_infinity::<f64>().atanh().is_NaN());
-        assert!(Float::NaN::<f64>().atanh().is_NaN());
-        assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
-        assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64);
-    }
-
     #[test]
     fn test_real_consts() {
         assert_approx_eq!(Real::two_pi::<f64>(), 2.0 * Real::pi::<f64>());