---

yaml
---
r: 114418
b: refs/heads/master
c: 3d63370
h: refs/heads/master
v: v3

Author: lucy

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 33c3eddd111bd708940f2e2fd84180cfae80e856
+refs/heads/master: 3d6337079fcd9299a1a9966d1ef51bd66bcaa814
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/src/doc/tutorial.md

@@ -1710,7 +1710,7 @@ it's possible to use *dynamic* mutability via types like `std::cell::Cell` where
 via dynamic checks and can fail at runtime.
 
 The `Rc` and `Gc` types are not sendable, so they cannot be used to share memory between tasks. Safe
-immutable and mutable shared memory is provided by the `sync::arc` module.
+immutable and mutable shared memory is provided by the `extra::arc` module.
 
 # Closures
 

trunk/src/libcollections/hashmap.rs

@@ -659,7 +659,7 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
 /// on creation by default, this means the ordering of the keys is
 /// randomized, but makes the tables more resistant to
 /// denial-of-service attacks (Hash DoS). This behaviour can be
-/// overridden with one of the constructors.
+/// overriden with one of the constructors.
 ///
 /// It is required that the keys implement the `Eq` and `Hash` traits, although
 /// this can frequently be achieved by using `#[deriving(Eq, Hash)]`.

trunk/src/libcore/cell.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Shareable mutable containers.
+//! Sharable mutable containers.
 //!
 //! Values of the `Cell` and `RefCell` types may be mutated through
 //! shared references (i.e. the common `&T` type), whereas most Rust
@@ -41,7 +41,7 @@
 //! preventing crash bugs. Because of that, inherited mutability is
 //! preferred, and interior mutability is something of a last
 //! resort. Since cell types enable mutation where it would otherwise
-//! be disallowed though, there are occasions when interior
+//! be disallowed though, there are occassions when interior
 //! mutability might be appropriate, or even *must* be used, e.g.
 //!
 //! * Introducing inherited mutability roots to shared types.

trunk/src/libcore/fmt/mod.rs

@@ -76,7 +76,7 @@ pub trait FormatWriter {
     /// This function will return an instance of `FormatError` on error.
     fn write(&mut self, bytes: &[u8]) -> Result;
 
-    /// Glue for usage of the `write!` macro with implementers of this trait.
+    /// Glue for usage of the `write!` macro with implementors of this trait.
     ///
     /// This method should generally not be invoked manually, but rather through
     /// the `write!` macro itself.

trunk/src/libcore/intrinsics.rs

@@ -360,110 +360,189 @@ extern "rust-intrinsic" {
     /// Perform a volatile store to the `dst` pointer.
     pub fn volatile_store<T>(dst: *mut T, val: T);
 
+    /// Returns the square root of an `f32`
     pub fn sqrtf32(x: f32) -> f32;
+    /// Returns the square root of an `f64`
     pub fn sqrtf64(x: f64) -> f64;
 
+    /// Raises an `f32` to an integer power.
     pub fn powif32(a: f32, x: i32) -> f32;
+    /// Raises an `f64` to an integer power.
     pub fn powif64(a: f64, x: i32) -> f64;
 
+    /// Returns the sine of an `f32`.
     pub fn sinf32(x: f32) -> f32;
+    /// Returns the sine of an `f64`.
     pub fn sinf64(x: f64) -> f64;
 
+    /// Returns the cosine of an `f32`.
     pub fn cosf32(x: f32) -> f32;
+    /// Returns the cosine of an `f64`.
     pub fn cosf64(x: f64) -> f64;
 
+    /// Raises an `f32` to an `f32` power.
     pub fn powf32(a: f32, x: f32) -> f32;
+    /// Raises an `f64` to an `f64` power.
     pub fn powf64(a: f64, x: f64) -> f64;
 
+    /// Returns the exponential of an `f32`.
     pub fn expf32(x: f32) -> f32;
+    /// Returns the exponential of an `f64`.
     pub fn expf64(x: f64) -> f64;
 
+    /// Returns 2 raised to the power of an `f32`.
     pub fn exp2f32(x: f32) -> f32;
+    /// Returns 2 raised to the power of an `f64`.
     pub fn exp2f64(x: f64) -> f64;
 
+    /// Returns the natural logarithm of an `f32`.
     pub fn logf32(x: f32) -> f32;
+    /// Returns the natural logarithm of an `f64`.
     pub fn logf64(x: f64) -> f64;
 
+    /// Returns the base 10 logarithm of an `f32`.
     pub fn log10f32(x: f32) -> f32;
+    /// Returns the base 10 logarithm of an `f64`.
     pub fn log10f64(x: f64) -> f64;
 
+    /// Returns the base 2 logarithm of an `f32`.
     pub fn log2f32(x: f32) -> f32;
+    /// Returns the base 2 logarithm of an `f64`.
     pub fn log2f64(x: f64) -> f64;
 
+    /// Returns `a * b + c` for `f32` values.
     pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
+    /// Returns `a * b + c` for `f64` values.
     pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
 
+    /// Returns the absolute value of an `f32`.
     pub fn fabsf32(x: f32) -> f32;
+    /// Returns the absolute value of an `f64`.
     pub fn fabsf64(x: f64) -> f64;
 
+    /// Copies the sign from `y` to `x` for `f32` values.
     pub fn copysignf32(x: f32, y: f32) -> f32;
+    /// Copies the sign from `y` to `x` for `f64` values.
     pub fn copysignf64(x: f64, y: f64) -> f64;
 
+    /// Returns the largest integer less than or equal to an `f32`.
     pub fn floorf32(x: f32) -> f32;
+    /// Returns the largest integer less than or equal to an `f64`.
     pub fn floorf64(x: f64) -> f64;
 
+    /// Returns the smallest integer greater than or equal to an `f32`.
     pub fn ceilf32(x: f32) -> f32;
+    /// Returns the smallest integer greater than or equal to an `f64`.
     pub fn ceilf64(x: f64) -> f64;
 
+    /// Returns the integer part of an `f32`.
     pub fn truncf32(x: f32) -> f32;
+    /// Returns the integer part of an `f64`.
     pub fn truncf64(x: f64) -> f64;
 
+    /// Returns the nearest integer to an `f32`. May raise an inexact floating-point exception
+    /// if the argument is not an integer.
     pub fn rintf32(x: f32) -> f32;
+    /// Returns the nearest integer to an `f64`. May raise an inexact floating-point exception
+    /// if the argument is not an integer.
     pub fn rintf64(x: f64) -> f64;
 
+    /// Returns the nearest integer to an `f32`.
     pub fn nearbyintf32(x: f32) -> f32;
+    /// Returns the nearest integer to an `f64`.
     pub fn nearbyintf64(x: f64) -> f64;
 
+    /// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
     pub fn roundf32(x: f32) -> f32;
+    /// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
     pub fn roundf64(x: f64) -> f64;
 
+    /// Returns the number of bits set in a `u8`.
     pub fn ctpop8(x: u8) -> u8;
+    /// Returns the number of bits set in a `u16`.
     pub fn ctpop16(x: u16) -> u16;
+    /// Returns the number of bits set in a `u32`.
     pub fn ctpop32(x: u32) -> u32;
+    /// Returns the number of bits set in a `u64`.
     pub fn ctpop64(x: u64) -> u64;
 
+    /// Returns the number of leading bits unset in a `u8`.
     pub fn ctlz8(x: u8) -> u8;
+    /// Returns the number of leading bits unset in a `u16`.
     pub fn ctlz16(x: u16) -> u16;
+    /// Returns the number of leading bits unset in a `u32`.
     pub fn ctlz32(x: u32) -> u32;
+    /// Returns the number of leading bits unset in a `u64`.
     pub fn ctlz64(x: u64) -> u64;
 
+    /// Returns the number of trailing bits unset in a `u8`.
     pub fn cttz8(x: u8) -> u8;
+    /// Returns the number of trailing bits unset in a `u16`.
     pub fn cttz16(x: u16) -> u16;
+    /// Returns the number of trailing bits unset in a `u32`.
     pub fn cttz32(x: u32) -> u32;
+    /// Returns the number of trailing bits unset in a `u64`.
     pub fn cttz64(x: u64) -> u64;
 
+    /// Reverses the bytes in a `u16`.
     pub fn bswap16(x: u16) -> u16;
+    /// Reverses the bytes in a `u32`.
     pub fn bswap32(x: u32) -> u32;
+    /// Reverses the bytes in a `u64`.
     pub fn bswap64(x: u64) -> u64;
 
+    /// Performs checked `i8` addition.
     pub fn i8_add_with_overflow(x: i8, y: i8) -> (i8, bool);
+    /// Performs checked `i16` addition.
     pub fn i16_add_with_overflow(x: i16, y: i16) -> (i16, bool);
+    /// Performs checked `i32` addition.
     pub fn i32_add_with_overflow(x: i32, y: i32) -> (i32, bool);
+    /// Performs checked `i64` addition.
     pub fn i64_add_with_overflow(x: i64, y: i64) -> (i64, bool);
 
+    /// Performs checked `u8` addition.
     pub fn u8_add_with_overflow(x: u8, y: u8) -> (u8, bool);
+    /// Performs checked `u16` addition.
     pub fn u16_add_with_overflow(x: u16, y: u16) -> (u16, bool);
+    /// Performs checked `u32` addition.
     pub fn u32_add_with_overflow(x: u32, y: u32) -> (u32, bool);
+    /// Performs checked `u64` addition.
     pub fn u64_add_with_overflow(x: u64, y: u64) -> (u64, bool);
 
+    /// Performs checked `i8` subtraction.
     pub fn i8_sub_with_overflow(x: i8, y: i8) -> (i8, bool);
+    /// Performs checked `i16` subtraction.
     pub fn i16_sub_with_overflow(x: i16, y: i16) -> (i16, bool);
+    /// Performs checked `i32` subtraction.
     pub fn i32_sub_with_overflow(x: i32, y: i32) -> (i32, bool);
+    /// Performs checked `i64` subtraction.
     pub fn i64_sub_with_overflow(x: i64, y: i64) -> (i64, bool);
 
+    /// Performs checked `u8` subtraction.
     pub fn u8_sub_with_overflow(x: u8, y: u8) -> (u8, bool);
+    /// Performs checked `u16` subtraction.
     pub fn u16_sub_with_overflow(x: u16, y: u16) -> (u16, bool);
+    /// Performs checked `u32` subtraction.
     pub fn u32_sub_with_overflow(x: u32, y: u32) -> (u32, bool);
+    /// Performs checked `u64` subtraction.
     pub fn u64_sub_with_overflow(x: u64, y: u64) -> (u64, bool);
 
+    /// Performs checked `i8` multiplication.
     pub fn i8_mul_with_overflow(x: i8, y: i8) -> (i8, bool);
+    /// Performs checked `i16` multiplication.
     pub fn i16_mul_with_overflow(x: i16, y: i16) -> (i16, bool);
+    /// Performs checked `i32` multiplication.
     pub fn i32_mul_with_overflow(x: i32, y: i32) -> (i32, bool);
+    /// Performs checked `i64` multiplication.
     pub fn i64_mul_with_overflow(x: i64, y: i64) -> (i64, bool);
 
+    /// Performs checked `u8` multiplication.
     pub fn u8_mul_with_overflow(x: u8, y: u8) -> (u8, bool);
+    /// Performs checked `u16` multiplication.
     pub fn u16_mul_with_overflow(x: u16, y: u16) -> (u16, bool);
+    /// Performs checked `u32` multiplication.
     pub fn u32_mul_with_overflow(x: u32, y: u32) -> (u32, bool);
+    /// Performs checked `u64` multiplication.
     pub fn u64_mul_with_overflow(x: u64, y: u64) -> (u64, bool);
 }
 

trunk/src/libcore/iter.rs

@@ -872,12 +872,10 @@ pub trait OrdIterator<A> {
     /// `min_max` finds the minimum and maximum elements in the iterator.
     ///
     /// The return type `MinMaxResult` is an enum of three variants:
-    ///
     /// - `NoElements` if the iterator is empty.
     /// - `OneElement(x)` if the iterator has exactly one element.
-    /// - `MinMax(x, y)` is returned otherwise, where `x <= y`. Two
-    ///    values are equal if and only if there is more than one
-    ///    element in the iterator and all elements are equal.
+    /// - `MinMax(x, y)` is returned otherwise, where `x <= y`. Two values are equal if and only if
+    /// there is more than one element in the iterator and all elements are equal.
     ///
     /// On an iterator of length `n`, `min_max` does `1.5 * n` comparisons,
     /// and so faster than calling `min` and `max separately which does `2 * n` comparisons.

trunk/src/libcore/kinds.rs

@@ -266,7 +266,7 @@ pub mod marker {
     #[deriving(Eq,Clone)]
     pub struct NoCopy;
 
-    /// A type which is considered "not shareable", meaning that
+    /// A type which is considered "not sharable", meaning that
     /// its contents are not threadsafe, hence they cannot be
     /// shared between tasks.
     #[lang="no_share_bound"]

trunk/src/libcore/result.rs

@@ -260,7 +260,7 @@
 //! The suitability of `fail!` as an error handling mechanism is
 //! limited by Rust's lack of any way to "catch" and resume execution
 //! from a thrown exception. Therefore using failure for error
-//! handling requires encapsulating fallible code in a task. Calling
+//! handling requires encapsulating fallable code in a task. Calling
 //! the `fail!` macro, or invoking `fail!` indirectly should be
 //! avoided as an error reporting strategy. Failure is only for
 //! unrecoverable errors and a failing task is typically the sign of

trunk/src/libgetopts/lib.rs

@@ -190,7 +190,7 @@ pub enum Fail_ {
     UnrecognizedOption(StrBuf),
     /// A required option is not present.
     OptionMissing(StrBuf),
-    /// A single occurrence option is being used multiple times.
+    /// A single occurence option is being used multiple times.
     OptionDuplicated(StrBuf),
     /// There's an argument being passed to a non-argument option.
     UnexpectedArgument(StrBuf),

trunk/src/libgraphviz/lib.rs

@@ -395,7 +395,7 @@ pub trait Labeller<'a,N,E> {
     fn graph_id(&'a self) -> Id<'a>;
 
     /// Maps `n` to a unique identifier with respect to `self`. The
-    /// implementer is responsible for ensuring that the returned name
+    /// implementor is responsible for ensuring that the returned name
     /// is a valid DOT identifier.
     fn node_id(&'a self, n: &N) -> Id<'a>;
 
@@ -457,7 +457,7 @@ pub type Edges<'a,E> = MaybeOwnedVector<'a,E>;
 /// that is bound by the self lifetime `'a`.
 ///
 /// The `nodes` and `edges` method each return instantiations of
-/// `MaybeOwnedVector` to leave implementers the freedom to create
+/// `MaybeOwnedVector` to leave implementors the freedom to create
 /// entirely new vectors or to pass back slices into internally owned
 /// vectors.
 pub trait GraphWalk<'a, N, E> {

trunk/src/libgraphviz/maybe_owned_vec.rs

@@ -31,7 +31,7 @@ use std::slice;
 /// Some clients will have a pre-allocated vector ready to hand off in
 /// a slice; others will want to create the set on the fly and hand
 /// off ownership, via either `Growable` or `FixedLen` depending on
-/// which kind of vector they have constructed.  (The `FixedLen`
+/// which kind of vector they have constucted.  (The `FixedLen`
 /// variant is provided for interoperability with `std::slice` methods
 /// that return `~[T]`.)
 pub enum MaybeOwnedVector<'a,T> {

trunk/src/libgreen/lib.rs

@@ -125,7 +125,7 @@
 //! }
 //! ```
 //!
-//! > **Note**: This `main` function in this example does *not* have I/O
+//! > **Note**: This `main` funciton in this example does *not* have I/O
 //! >           support. The basic event loop does not provide any support
 //!
 //! # Starting with I/O support in libgreen

trunk/src/libnative/io/timer_unix.rs

@@ -23,7 +23,7 @@
 //!
 //! Whenever the call to select() times out, then a channel receives a message.
 //! Whenever the call returns that the file descriptor has information, then the
-//! channel from timers is drained, enqueuing all incoming requests.
+//! channel from timers is drained, enqueueing all incoming requests.
 //!
 //! The actual implementation of the helper thread is a sorted array of
 //! timers in terms of target firing date. The target is the absolute time at
@@ -42,7 +42,7 @@
 //! thread. Whenever the timer is modified, it first takes ownership back from
 //! the worker thread in order to modify the same data structure. This has the
 //! side effect of "cancelling" the previous requests while allowing a
-//! re-enqueuing later on.
+//! re-enqueueing later on.
 //!
 //! Note that all time units in this file are in *milliseconds*.
 

trunk/src/librustc/middle/borrowck/doc.rs

@@ -424,7 +424,7 @@ the pointer itself `LV` goes out of scope:
 ```
 
 The scope of a managed referent is also the scope of the pointer.  This
-is a conservative approximation, since there may be other aliases for
+is a conservative approximation, since there may be other aliases fo
 that same managed box that would cause it to live longer:
 
 ```notrust
@@ -536,7 +536,7 @@ The final rules govern the computation of *restrictions*, meaning that
 we compute the set of actions that will be illegal for the life of the
 loan. The predicate is written `RESTRICTIONS(LV, LT, ACTIONS) =
 RESTRICTION*`, which can be read "in order to prevent `ACTIONS` from
-occurring on `LV`, the restrictions `RESTRICTION*` must be respected
+occuring on `LV`, the restrictions `RESTRICTION*` must be respected
 for the lifetime of the loan".
 
 Note that there is an initial set of restrictions: these restrictions
@@ -551,7 +551,7 @@ are computed based on the kind of borrow:
 The reasoning here is that a mutable borrow must be the only writer,
 therefore it prevents other writes (`MUTATE`), mutable borrows
 (`CLAIM`), and immutable borrows (`FREEZE`). An immutable borrow
-permits other immutable borrows but forbids writes and mutable borows.
+permits other immutable borows but forbids writes and mutable borows.
 Finally, a const borrow just wants to be sure that the value is not
 moved out from under it, so no actions are forbidden.
 

trunk/src/librustc/middle/trans/context.rs

@@ -73,7 +73,7 @@ pub struct CrateContext {
     /// came from)
     pub external_srcs: RefCell<NodeMap<ast::DefId>>,
     /// A set of static items which cannot be inlined into other crates. This
-    /// will prevent in IIItem() structures from being encoded into the metadata
+    /// will pevent in IIItem() structures from being encoded into the metadata
     /// that is generated
     pub non_inlineable_statics: RefCell<NodeSet>,
     /// Cache instances of monomorphized functions

trunk/src/librustc/middle/typeck/infer/doc.rs

@@ -244,7 +244,7 @@ yet, that's what we're trying to find!  In our code, we opt to unify
 
 # Implementation details
 
-We make use of a trait-like implementation strategy to consolidate
+We make use of a trait-like impementation strategy to consolidate
 duplicated code between subtypes, GLB, and LUB computations.  See the
 section on "Type Combining" below for details.
 

trunk/src/librustuv/timeout.rs

@@ -21,7 +21,7 @@ use uvio::UvIoFactory;
 use {Loop, UvError, uv_error_to_io_error, Request, wakeup};
 use {UvHandle, wait_until_woken_after};
 
-/// Management of a timeout when gaining access to a portion of a duplex stream.
+/// Managment of a timeout when gaining access to a portion of a duplex stream.
 pub struct AccessTimeout {
     state: TimeoutState,
     timer: Option<Box<TimerWatcher>>,