add spaces before newlines in rustdocs

Author: rtanglao

src/libcore/char.rs

@@ -45,24 +45,24 @@ import is_XID_continue = unicode::derived_property::XID_Continue;
 
 
 #[doc(
-  brief = "Indicates whether a character is in lower case, defined\
+  brief = "Indicates whether a character is in lower case, defined \
            in terms of the Unicode General Category 'Ll'."
 )]
 pure fn is_lowercase(c: char) -> bool {
     ret unicode::general_category::Ll(c);
 }
 
 #[doc(
-  brief = "Indicates whether a character is in upper case, defined\
+  brief = "Indicates whether a character is in upper case, defined \
            in terms of the Unicode General Category 'Lu'."
 )]
 pure fn is_uppercase(c: char) -> bool {
     ret unicode::general_category::Lu(c);
 }
 
 #[doc(
-  brief = "Indicates whether a character is whitespace, defined in\
-           terms of the Unicode General Categories 'Zs', 'Zl', 'Zp'\
+  brief = "Indicates whether a character is whitespace, defined in \
+           terms of the Unicode General Categories 'Zs', 'Zl', 'Zp' \
            additional 'Cc'-category control codes in the range [0x09, 0x0d]"
 )]
 pure fn is_whitespace(c: char) -> bool {
@@ -73,8 +73,8 @@ pure fn is_whitespace(c: char) -> bool {
 }
 
 #[doc(
-  brief = "Indicates whether a character is alphanumeric, defined\
-            in terms of the Unicode General Categories 'Nd',\
+  brief = "Indicates whether a character is alphanumeric, defined \
+            in terms of the Unicode General Categories 'Nd', \
             'Nl', 'No' and the Derived Core Property 'Alphabetic'."
 )]
 pure fn is_alphanumeric(c: char) -> bool {
@@ -86,10 +86,10 @@ pure fn is_alphanumeric(c: char) -> bool {
 
 
 #[doc(
-  brief = "Convert a char to the corresponding digit.\
+  brief = "Convert a char to the corresponding digit. \
            Safety note: This function fails if `c` is not a valid char",
-  return = "If `c` is between '0' and '9', the corresponding value\
-            between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is\
+  return = "If `c` is between '0' and '9', the corresponding value \
+            between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is \
             'b' or 'B', 11, etc."
 )]
 pure fn to_digit(c: char) -> u8 unsafe {
@@ -100,7 +100,7 @@ pure fn to_digit(c: char) -> u8 unsafe {
 }
 
 #[doc(
-  brief = "Convert a char to the corresponding digit. Returns none when\
+  brief = "Convert a char to the corresponding digit. Returns none when \
            character is not a valid hexadecimal digit."
 )]
 pure fn maybe_digit(c: char) -> option::t<u8> {

src/libcore/comm.rs

@@ -1,19 +1,19 @@
 #[doc(
   brief = "Communication between tasks",
-  desc  = "Communication between tasks is facilitated by ports (in the\
-           receiving task), and channels (in the sending task). Any\
-           number of channels may feed into a single port.\
-           Ports and channels may only transmit values of unique\
-           types; that is, values that are statically guaranteed to\
-           be accessed by a single 'owner' at a time.  Unique types\
-           include scalars, vectors, strings, and records, tags,\
-           tuples and unique boxes (~T) thereof. Most notably,\
-           shared boxes (@T) may not be transmitted across channels.\
-           Example:\
-               let p = comm::port();\
-               task::spawn(comm::chan(p), fn (c: chan<str>) {\
-                   comm::send(c, \"Hello, World\");\
-               });\
+  desc  = "Communication between tasks is facilitated by ports (in the \
+           receiving task), and channels (in the sending task). Any \
+           number of channels may feed into a single port. \
+           Ports and channels may only transmit values of unique \
+           types; that is, values that are statically guaranteed to \
+           be accessed by a single 'owner' at a time.  Unique types \
+           include scalars, vectors, strings, and records, tags, \
+           tuples and unique boxes (~T) thereof. Most notably, \
+           shared boxes (@T) may not be transmitted across channels. \
+           Example: \
+               let p = comm::port(); \
+               task::spawn(comm::chan(p), fn (c: chan&lt;str>) { \
+                   comm::send(c, \"Hello, World\"); \
+               }); \
                io::println(comm::recv(p));"
 )];
 
@@ -82,18 +82,18 @@ resource port_ptr<T: send>(po: *rustrt::rust_port) {
 }
 
 #[doc(
-  brief = "A communication endpoint that can receive messages.\
+  brief = "A communication endpoint that can receive messages. \
            Ports receive messages from channels.",
-  desc = "Each port has a unique per-task identity and may not\
-          be replicated or transmitted. If a port value is\
-          copied, both copies refer to the same port.\
+  desc = "Each port has a unique per-task identity and may not \
+          be replicated or transmitted. If a port value is \
+          copied, both copies refer to the same port. \
           Ports may be associated with multiple &lt;chan>s."
 )]
 tag port<T: send> { port_t(@port_ptr<T>); }
 
 #[doc(
-  brief = "Sends data over a channel. The sent data is moved\
-           into the channel, whereupon the caller loses\
+  brief = "Sends data over a channel. The sent data is moved \
+           into the channel, whereupon the caller loses \
            access to it."
 )]
 fn send<T: send>(ch: chan<T>, -data: T) {
@@ -114,8 +114,8 @@ fn port<T: send>() -> port<T> {
 }
 
 #[doc(
-  brief = "Receive from a port.\
-           If no data is available on the port then the task will\
+  brief = "Receive from a port. \
+           If no data is available on the port then the task will \
            block until data becomes available."
 )]
 fn recv<T: send>(p: port<T>) -> T { recv_(***p) }

src/libcore/ctypes.rs

@@ -52,24 +52,24 @@ type ulong = uint;
 type ulonglong = u64;
 
 #[doc(
-  brief = "A signed integer with the same size as a pointer.\
-           This is guaranteed to always be the same type as a\
+  brief = "A signed integer with the same size as a pointer. \
+           This is guaranteed to always be the same type as a \
             Rust `int`."
 )]
 type intptr_t = uint; // FIXME: int
 
 #[doc(
-  brief = "An unsigned integer with the same size as a pointer.\
-           This is guaranteed to always be the same type as a Rust\
+  brief = "An unsigned integer with the same size as a pointer. \
+           This is guaranteed to always be the same type as a Rust \
            `uint`."
 )]
 type uintptr_t = uint;
 type uint32_t = u32;
 
 #[doc(
   brief = "A type, a pointer to which can be used as C `void *`.",
-  desc = "The void type cannot be constructed or destructured,\
-         but using pointers to this type when interoperating\
+  desc = "The void type cannot be constructed or destructured, \
+         but using pointers to this type when interoperating \
          with C void pointers can help in documentation."
 )]
 tag void {
@@ -116,8 +116,8 @@ type fd_t = i32;      // not actually a C type, but should be.
 type pid_t = i32;
 
 #[doc(
-  brief = "An unsigned integer with the same size as a C enum.\
-           enum is implementation-defined, but is 32-bits in\
+  brief = "An unsigned integer with the same size as a C enum. \
+           enum is implementation-defined, but is 32-bits in \
            practice"
 )]
 type enum = u32;