Revised comments and fixed a deref issue in libsyntax\parse\parser\expr.rs

Author: Ruster-a11y

src/liballoc/string.rs

@@ -1982,8 +1982,9 @@ impl Add<&str> for String {
     }
 }
 
+// This had to be added to avoid breakage after adding `impl Add<char> for String`
 #[allow(missing_docs)]
-#[stable(feature = "add_string_and_dbl_ref_str", since = "1.41.0")]
+#[stable(feature = "extra_add_string_and_dbl_ref_str", since = "1.41.0")]
 impl Add<&&str> for String {
     type Output = String;
 
@@ -1994,44 +1995,9 @@ impl Add<&&str> for String {
     }
 }
 
-/// Implements the `+` operator for concatenating two `String`s.
-///
-/// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if
-/// necessary). This is done to avoid allocating a new `String` and copying the entire contents on
-/// every operation, which would lead to `O(n^2)` running time when building an `n`-byte string by
-/// repeated concatenation.
-///
-/// The string on the right-hand side is only borrowed; its contents are copied into the returned
-/// `String`.
-///
-/// # Examples
-///
-/// Concatenating two `String`s takes the first by value and borrows the second:
-///
-/// ```
-/// let a = String::from("hello");
-/// let b = String::from(" world");
-/// let c = a + &b;
-/// // `a` is moved and can no longer be used here.
-/// ```
-///
-/// If you want to keep using the first `String`, you can clone it and append to the clone instead:
-///
-/// ```
-/// let a = String::from("hello");
-/// let b = String::from(" world");
-/// let c = a.clone() + &b;
-/// // `a` is still valid here.
-/// ```
-///
-/// Concatenating `&str` slices can be done by converting the first to a `String`:
-///
-/// ```
-/// let a = "hello";
-/// let b = " world";
-/// let c = a.to_string() + b;
-/// ```
-#[stable(feature = "add_string_and_ref_string", since = "1.41.0")]
+// This had to be added to avoid breakage after adding `impl Add<char> for String`
+#[allow(missing_docs)]
+#[stable(feature = "extra_add_string_and_ref_string", since = "1.41.0")]
 impl Add<&String> for String {
     type Output = String;
 
@@ -2042,8 +2008,9 @@ impl Add<&String> for String {
     }
 }
 
+// This had to be added to avoid breakage after adding `impl Add<char> for String`
 #[allow(missing_docs)]
-#[stable(feature = "add_string_and_dbl_ref_string", since = "1.41.0")]
+#[stable(feature = "extra_add_string_and_dbl_ref_string", since = "1.41.0")]
 impl Add<&&String> for String {
     type Output = String;
 
@@ -2114,7 +2081,7 @@ impl AddAssign<&str> for String {
 /// Implements the `+=` operator for appending to a `String`.
 ///
 /// This has the same behavior as the [`push_str`][String::push_str] method.
-#[stable(feature = "stringaddassign_string", since = "1.41.0")]
+#[stable(feature = "string_add_assign_string", since = "1.41.0")]
 impl AddAssign<&String> for String {
     #[inline]
     fn add_assign(&mut self, other: &String) {
@@ -2125,7 +2092,7 @@ impl AddAssign<&String> for String {
 /// Implements the `+=` operator for appending a `char` to a `String`.
 ///
 /// This has the same behavior as the [`push`][String::push] method.
-#[stable(feature = "stringaddassign_char", since = "1.41.0")]
+#[stable(feature = "string_add_assign_char", since = "1.41.0")]
 impl AddAssign<char> for String {
     #[inline]
     fn add_assign(&mut self, other: char) {

src/libsyntax/parse/parser/expr.rs

@@ -1084,10 +1084,7 @@ impl<'a> Parser<'a> {
                 if let token::Literal(token::Lit { kind: token::Integer, symbol, suffix })
                         = next_token.kind {
                     if self.token.span.hi() == next_token.span.lo() {
-                        // FIXME: Should just be `&symbol.as_str()` but can't as of now due to
-                        // Deref coercion.
-                        // Issue: https://github.com/rust-lang/rust/issues/51916
-                        let s = String::from("0.") + &symbol.as_str().get_str();
+                        let s = String::from("0.") + &*symbol.as_str();
                         let kind = TokenKind::lit(token::Float, Symbol::intern(&s), suffix);
                         return Some(Token::new(kind, self.token.span.to(next_token.span)));
                     }

src/libsyntax_pos/symbol.rs

@@ -1104,15 +1104,6 @@ pub struct SymbolStr {
     string: &'static str,
 }
 
-/// FIXME: This is not needed once we are able to fix the Deref coercion issue.
-/// Issue: https://github.com/rust-lang/rust/issues/51916
-impl SymbolStr {
-    #[inline]
-    pub fn get_str(&self) -> &str {
-        self.string
-    }
-}
-
 // This impl allows a `SymbolStr` to be directly equated with a `String` or
 // `&str`.
 impl<T: std::ops::Deref<Target = str>> std::cmp::PartialEq<T> for SymbolStr {
@@ -1129,10 +1120,6 @@ impl !Sync for SymbolStr {}
 /// - `&*ss` is a `&str`;
 /// - `&ss as &str` is a `&str`, which means that `&ss` can be passed to a
 ///   function expecting a `&str`.
-///
-/// FIXME: This has no meaning anymore since the addition of `impl Add<char> for String`.
-/// Due to the outstanding Deref coercion issue this Deref implementation gets ignored.
-/// Issue: https://github.com/rust-lang/rust/issues/51916
 impl std::ops::Deref for SymbolStr {
     type Target = str;
     #[inline]