From 877d55c1e09a58f7999dcc4b650ad0a42c9b312e Mon Sep 17 00:00:00 2001 From: James Mantooth Date: Sat, 2 Jan 2016 01:26:22 -0600 Subject: [PATCH] Grammar fixes --- src/libstd/panic.rs | 12 ++++++------ src/libsyntax/ast.rs | 10 +++++----- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/libstd/panic.rs b/src/libstd/panic.rs index b42d1d1b8d4ce..76d9c194b4520 100644 --- a/src/libstd/panic.rs +++ b/src/libstd/panic.rs @@ -41,15 +41,15 @@ pub use panicking::{take_handler, set_handler, PanicInfo, Location}; /// panics. /// 2. This broken invariant is then later observed. /// -/// Typically in Rust it is difficult to perform step (2) because catching a +/// Typically in Rust, it is difficult to perform step (2) because catching a /// panic involves either spawning a thread (which in turns makes it difficult /// to later witness broken invariants) or using the `recover` function in this -/// module. Additionally, even if an invariant is witness, it typically isn't a +/// module. Additionally, even if an invariant is witnessed, it typically isn't a /// problem in Rust because there's no uninitialized values (like in C or C++). /// /// It is possible, however, for **logical** invariants to be broken in Rust, /// which can end up causing behavioral bugs. Another key aspect of panic safety -/// in Rust is that in the absence of `unsafe` code, a panic cannot lead to +/// in Rust is that, in the absence of `unsafe` code, a panic cannot lead to /// memory unsafety. /// /// That was a bit of a whirlwind tour of panic safety, but for more information @@ -60,12 +60,12 @@ pub use panicking::{take_handler, set_handler, PanicInfo, Location}; /// ## What is `RecoverSafe`? /// /// Now that we've got an idea of what panic safety is in Rust, it's also -/// important to understand that this trait represents. As mentioned above, one +/// important to understand what this trait represents. As mentioned above, one /// way to witness broken invariants is through the `recover` function in this /// module as it allows catching a panic and then re-using the environment of /// the closure. /// -/// Simply but, a type `T` implements `RecoverSafe` if it cannot easily allow +/// Simply put, a type `T` implements `RecoverSafe` if it cannot easily allow /// witnessing a broken invariant through the use of `recover` (catching a /// panic). This trait is a marker trait, so it is automatically implemented for /// many types, and it is also structurally composed (e.g. a struct is recover @@ -180,7 +180,7 @@ impl RecoverSafe for Arc {} // Pretty simple implementations for the `RefRecoverSafe` marker trait, // basically just saying that this is a marker trait and `UnsafeCell` is the // only thing which doesn't implement it (which then transitively applies to -// everything else. +// everything else). impl RefRecoverSafe for .. {} impl !RefRecoverSafe for UnsafeCell {} impl RefRecoverSafe for AssertRecoverSafe {} diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 9617ae6bae54c..e327adfaf892c 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -334,7 +334,7 @@ pub struct AngleBracketedParameterData { /// The type parameters for this path segment, if present. pub types: P<[P]>, /// Bindings (equality constraints) on associated types, if present. - /// E.g., `Foo`. + /// e.g., `Foo`. pub bindings: P<[P]>, } @@ -447,7 +447,7 @@ pub struct WhereClause { /// A single predicate in a `where` clause #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum WherePredicate { - /// A type binding, eg `for<'c> Foo: Send+Clone+'c` + /// A type binding, e.g. `for<'c> Foo: Send+Clone+'c` BoundPredicate(WhereBoundPredicate), /// A lifetime predicate, e.g. `'a: 'b+'c` RegionPredicate(WhereRegionPredicate), @@ -455,7 +455,7 @@ pub enum WherePredicate { EqPredicate(WhereEqPredicate), } -/// A type bound, eg `for<'c> Foo: Send+Clone+'c` +/// A type bound, e.g. `for<'c> Foo: Send+Clone+'c` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct WhereBoundPredicate { pub span: Span, @@ -1095,7 +1095,7 @@ impl Delimited { } } -/// A sequence of token treesee +/// A sequence of token trees #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct SequenceRepetition { /// The sequence of token trees @@ -1346,7 +1346,7 @@ pub struct MethodSig { } /// Represents a method declaration in a trait declaration, possibly including -/// a default implementation A trait method is either required (meaning it +/// a default implementation. A trait method is either required (meaning it /// doesn't have an implementation, just a signature) or provided (meaning it /// has a default implementation). #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]