---

yaml
---
r: 153401
b: refs/heads/try2
c: c5edc70
h: refs/heads/master
i:
  153399: a063000
v: v3

Author: erickt

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 0a1e251e81b0849fa5bd86b6fe0f2f5312d50bb5
+refs/heads/try2: c5edc70fadd136c0e0b1fe402fbb3170e94458aa
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcollections/str.rs

@@ -352,15 +352,6 @@ impl<'a> Iterator<char> for Decompositions<'a> {
 /// # Return value
 ///
 /// The original string with all occurrences of `from` replaced with `to`
-///
-/// # Example
-///
-/// ```rust
-/// use std::str;
-/// let string = "orange";
-/// let new_string = str::replace(string, "or", "str");
-/// assert_eq!(new_string.as_slice(), "strange");
-/// ```
 pub fn replace(s: &str, from: &str, to: &str) -> String {
     let mut result = String::new();
     let mut last_end = 0;
@@ -582,14 +573,6 @@ pub type SendStr = MaybeOwned<'static>;
 
 impl<'a> MaybeOwned<'a> {
     /// Returns `true` if this `MaybeOwned` wraps an owned string
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let string = String::from_str("orange");
-    /// let maybe_owned_string = string.into_maybe_owned();
-    /// assert_eq!(true, maybe_owned_string.is_owned());
-    /// ```
     #[inline]
     pub fn is_owned(&self) -> bool {
         match *self {
@@ -599,14 +582,6 @@ impl<'a> MaybeOwned<'a> {
     }
 
     /// Returns `true` if this `MaybeOwned` wraps a borrowed string
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let string = "orange";
-    /// let maybe_owned_string = string.as_slice().into_maybe_owned();
-    /// assert_eq!(true, maybe_owned_string.is_slice());
-    /// ```
     #[inline]
     pub fn is_slice(&self) -> bool {
         match *self {
@@ -622,40 +597,18 @@ pub trait IntoMaybeOwned<'a> {
     fn into_maybe_owned(self) -> MaybeOwned<'a>;
 }
 
-/// # Example
-///
-/// ```rust
-/// let owned_string = String::from_str("orange");
-/// let maybe_owned_string = owned_string.into_maybe_owned();
-/// assert_eq!(true, maybe_owned_string.is_owned());
-/// ```
 impl<'a> IntoMaybeOwned<'a> for String {
     #[inline]
     fn into_maybe_owned(self) -> MaybeOwned<'a> {
         Owned(self)
     }
 }
 
-/// # Example
-///
-/// ```rust
-/// let string = "orange";
-/// let maybe_owned_str = string.as_slice().into_maybe_owned();
-/// assert_eq!(false, maybe_owned_str.is_owned());
-/// ```
 impl<'a> IntoMaybeOwned<'a> for &'a str {
     #[inline]
     fn into_maybe_owned(self) -> MaybeOwned<'a> { Slice(self) }
 }
 
-/// # Example
-///
-/// ```rust
-/// let str = "orange";
-/// let maybe_owned_str = str.as_slice().into_maybe_owned();
-/// let maybe_maybe_owned_str = maybe_owned_str.into_maybe_owned();
-/// assert_eq!(false, maybe_maybe_owned_str.is_owned());
-/// ```
 impl<'a> IntoMaybeOwned<'a> for MaybeOwned<'a> {
     #[inline]
     fn into_maybe_owned(self) -> MaybeOwned<'a> { self }

branches/try2/src/libnative/io/process.rs

@@ -305,25 +305,6 @@ fn spawn_process_os(cfg: ProcessConfig,
         })
     }
 
-    // To have the spawning semantics of unix/windows stay the same, we need to
-    // read the *child's* PATH if one is provided. See #15149 for more details.
-    let program = cfg.env.and_then(|env| {
-        for &(ref key, ref v) in env.iter() {
-            if b"PATH" != key.as_bytes_no_nul() { continue }
-
-            // Split the value and test each path to see if the program exists.
-            for path in os::split_paths(v.as_bytes_no_nul()).move_iter() {
-                let path = path.join(cfg.program.as_bytes_no_nul())
-                               .with_extension(os::consts::EXE_EXTENSION);
-                if path.exists() {
-                    return Some(path.to_c_str())
-                }
-            }
-            break
-        }
-        None
-    });
-
     unsafe {
         let mut si = zeroed_startupinfo();
         si.cb = mem::size_of::<STARTUPINFO>() as DWORD;
@@ -381,8 +362,7 @@ fn spawn_process_os(cfg: ProcessConfig,
         try!(set_fd(&out_fd, &mut si.hStdOutput, false));
         try!(set_fd(&err_fd, &mut si.hStdError, false));
 
-        let cmd_str = make_command_line(program.as_ref().unwrap_or(cfg.program),
-                                        cfg.args);
+        let cmd_str = make_command_line(cfg.program, cfg.args);
         let mut pi = zeroed_process_information();
         let mut create_err = None;
 

branches/try2/src/libstd/io/mod.rs

@@ -293,7 +293,7 @@ pub type IoResult<T> = Result<T, IoError>;
 /// # FIXME
 ///
 /// Is something like this sufficient? It's kind of archaic
-#[deriving(PartialEq, Clone)]
+#[deriving(PartialEq, Eq, Clone)]
 pub struct IoError {
     /// An enumeration which can be matched against for determining the flavor
     /// of error.
@@ -435,7 +435,7 @@ impl fmt::Show for IoError {
 }
 
 /// A list specifying general categories of I/O error.
-#[deriving(PartialEq, Clone, Show)]
+#[deriving(PartialEq, Eq, Clone, Show)]
 pub enum IoErrorKind {
     /// Any I/O error not part of this list.
     OtherIoError,

branches/try2/src/libstd/os.rs

@@ -837,24 +837,13 @@ pub fn tmpdir() -> Path {
     }
 }
 
-///
-/// Convert a relative path to an absolute path
-///
-/// If the given path is relative, return it prepended with the current working
-/// directory. If the given path is already an absolute path, return it
-/// as is.
-///
-/// # Example
-/// ```rust
-/// use std::os;
-/// use std::path::Path;
-///
-/// // Assume we're in a path like /home/someuser
-/// let rel_path = Path::new("..");
-/// let abs_path = os::make_absolute(&rel_path);
-/// println!("The absolute path is {}", abs_path.display());
-/// // Prints "The absolute path is /home"
-/// ```
+/**
+ * Convert a relative path to an absolute path
+ *
+ * If the given path is relative, return it prepended with the current working
+ * directory. If the given path is already an absolute path, return it
+ * as is.
+ */
 // NB: this is here rather than in path because it is a form of environment
 // querying; what it does depends on the process working directory, not just
 // the input paths.
@@ -870,16 +859,6 @@ pub fn make_absolute(p: &Path) -> Path {
 
 /// Changes the current working directory to the specified path, returning
 /// whether the change was completed successfully or not.
-///
-/// # Example
-/// ```rust
-/// use std::os;
-/// use std::path::Path;
-///
-/// let root = Path::new("/");
-/// assert!(os::change_dir(&root));
-/// println!("Succesfully changed working directory to {}!", root.display());
-/// ```
 pub fn change_dir(p: &Path) -> bool {
     return chdir(p);
 
@@ -951,13 +930,6 @@ pub fn errno() -> uint {
 }
 
 /// Return the string corresponding to an `errno()` value of `errnum`.
-/// # Example
-/// ```rust
-/// use std::os;
-///
-/// // Same as println!("{}", last_os_error());
-/// println!("{}", os::error_string(os::errno() as uint));
-/// ```
 pub fn error_string(errnum: uint) -> String {
     return strerror(errnum);
 
@@ -1245,16 +1217,6 @@ extern "system" {
 ///
 /// The arguments are interpreted as utf-8, with invalid bytes replaced with \uFFFD.
 /// See `str::from_utf8_lossy` for details.
-/// # Example
-///
-/// ```rust
-/// use std::os;
-///
-/// // Prints each argument on a separate line
-/// for argument in os::args().iter() {
-///     println!("{}", argument);
-/// }
-/// ```
 pub fn args() -> Vec<String> {
     real_args()
 }