Rename std::fs::soft_link to std::fs::symlink

The term "soft link" is not used in any other APIs or formal
documentation on symbolic links, making this name somewhat surprising
and hard to find.  Switch to the more commonly recognized, but still
reasonably short, std::fs::symlink instead.

Because this is a stable API in the beta period, the old name is
retained but marked deprecated as a wrapper around the new name.

Author: lambda

src/libstd/fs.rs

@@ -699,7 +699,7 @@ pub fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// Given a path, query the file system to get information about a file,
 /// directory, etc.
 ///
-/// This function will traverse soft links to query information about the
+/// This function will traverse symbolic links to query information about the
 /// destination file.
 ///
 /// # Examples
@@ -811,31 +811,40 @@ pub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<(
     fs_imp::link(src.as_ref(), dst.as_ref())
 }
 
-/// Creates a new soft link on the filesystem.
+/// Creates a new symbolic link on the filesystem.
 ///
-/// The `dst` path will be a soft link pointing to the `src` path.
+/// The `dst` path will be a symbolic link pointing to the `src` path.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::fs;
 ///
 /// # fn foo() -> std::io::Result<()> {
-/// try!(fs::soft_link("a.txt", "b.txt"));
+/// try!(fs::symlink("a.txt", "b.txt"));
 /// # Ok(())
 /// # }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()> {
+pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()> {
     fs_imp::symlink(src.as_ref(), dst.as_ref())
 }
 
-/// Reads a soft link, returning the file that the link points to.
+/// Creates a new symbolic link on the filesystem.
+///
+/// Replaced by `std::fs::symlink`.
+#[deprecated(since = "1.0.0", reason = "replaced with std::fs::symlink")]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()> {
+    symlink(src, dst)
+}
+
+/// Reads a symbolic link, returning the file that the link points to.
 ///
 /// # Errors
 ///
 /// This function will return an error on failure. Failure conditions include
-/// reading a file that does not exist or reading a file that is not a soft
+/// reading a file that does not exist or reading a file that is not a symbolic
 /// link.
 ///
 /// # Examples
@@ -928,8 +937,8 @@ pub fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// Removes a directory at this path, after removing all its contents. Use
 /// carefully!
 ///
-/// This function does **not** follow soft links and it will simply remove the
-/// soft link itself.
+/// This function does **not** follow symbolic links and it will simply remove the
+/// symbolic link itself.
 ///
 /// # Errors
 ///
@@ -1528,7 +1537,7 @@ mod tests {
         check!(fs::create_dir_all(&dtt));
         check!(fs::create_dir_all(&d2));
         check!(check!(File::create(&canary)).write(b"foo"));
-        check!(fs::soft_link(&d2, &dt.join("d2")));
+        check!(fs::symlink(&d2, &dt.join("d2")));
         check!(fs::remove_dir_all(&d1));
 
         assert!(!d1.is_dir());
@@ -1658,7 +1667,7 @@ mod tests {
         let out = tmpdir.join("out.txt");
 
         check!(check!(File::create(&input)).write("foobar".as_bytes()));
-        check!(fs::soft_link(&input, &out));
+        check!(fs::symlink(&input, &out));
         // if cfg!(not(windows)) {
         //     assert_eq!(check!(lstat(&out)).kind, FileType::Symlink);
         //     assert_eq!(check!(out.lstat()).kind, FileType::Symlink);
@@ -1675,7 +1684,7 @@ mod tests {
     fn symlink_noexist() {
         let tmpdir = tmpdir();
         // symlinks can point to things that don't exist
-        check!(fs::soft_link(&tmpdir.join("foo"), &tmpdir.join("bar")));
+        check!(fs::symlink(&tmpdir.join("foo"), &tmpdir.join("bar")));
         assert_eq!(check!(fs::read_link(&tmpdir.join("bar"))),
                    tmpdir.join("foo"));
     }

src/libstd/old_io/fs.rs

@@ -498,7 +498,7 @@ pub fn link(src: &Path, dst: &Path) -> IoResult<()> {
 
 /// Creates a new symbolic link on the filesystem. The `dst` path will be a
 /// symlink pointing to the `src` path.
-#[deprecated(since = "1.0.0", reason = "replaced with std::fs::soft_link")]
+#[deprecated(since = "1.0.0", reason = "replaced with std::fs::symlink")]
 #[unstable(feature = "old_io")]
 pub fn symlink(src: &Path, dst: &Path) -> IoResult<()> {
     fs_imp::symlink(src, dst)