Rollup of 15 pull requests

README.md

@@ -1,7 +1,9 @@
-# The Rust Programming Language
+<a href = "https://www.rust-lang.org/"> 
+<img width = "90%" height = "auto" src = "https://img.shields.io/badge/Rust-Programming%20Language-black?style=flat&logo=rust" alt = "The Rust Programming Language">
+</a>
 
 This is the main source code repository for [Rust]. It contains the compiler,
-standard library, and documentation.
+standard library, and documentation. 
 
 [Rust]: https://www.rust-lang.org
 
@@ -17,9 +19,9 @@ Read ["Installation"] from [The Book].
 _Note: If you wish to contribute to the compiler, you should read [this
 chapter][rustcguidebuild] of the rustc-dev-guide instead of this section._
 
-The Rust build system has a Python script called `x.py` to bootstrap building
-the compiler. More information about it may be found by running `./x.py --help`
-or reading the [rustc dev guide][rustcguidebuild].
+The Rust build system uses a Python script called `x.py` to build the compiler,
+which manages the bootstrapping process. More information about it can be found 
+by running `./x.py --help` or reading the [rustc dev guide][rustcguidebuild].
 
 [rustcguidebuild]: https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html
 
@@ -54,9 +56,8 @@ or reading the [rustc dev guide][rustcguidebuild].
  $ cp config.toml.example config.toml
  ```
 
- It is recommended that if you plan to use the Rust build system to create
- an installation (using `./x.py install`) that you set the `prefix` value
- in the `[install]` section to a directory that you have write permissions.
+ If you plan to use `x.py install` to create an installation, it is recommended
+ that you set the `prefix` value in the `[install]` section to a directory.
 
  Create install directory if you are not installing in default directory
 
@@ -143,8 +144,8 @@ shell with:
 ```
 
 Currently, building Rust only works with some known versions of Visual Studio. If
-you have a more recent version installed the build system doesn't understand
-then you may need to force rustbuild to use an older version. This can be done
+you have a more recent version installed and the build system doesn't understand,
+you may need to force rustbuild to use an older version. This can be done
 by manually calling the appropriate vcvars file before running the bootstrap.
 
 ```batch

src/liballoc/boxed.rs

@@ -384,7 +384,10 @@ impl<T: ?Sized> Box<T> {
  ///
  /// unsafe {
  /// let ptr = alloc(Layout::new::<i32>()) as *mut i32;
- /// *ptr = 5;
+ /// // In general .write is required to avoid attempting to destruct
+ /// // the (uninitialized) previous contents of `ptr`, though for this
+ /// // simple example `*ptr = 5` would have worked as well.
+ /// ptr.write(5);
  /// let x = Box::from_raw(ptr);
  /// }
  /// ```

src/liballoc/string.rs

@@ -2518,3 +2518,11 @@ impl DoubleEndedIterator for Drain<'_> {
 
 #[stable(feature = "fused", since = "1.26.0")]
 impl FusedIterator for Drain<'_> {}
+
+#[stable(feature = "from_char_for_string", since = "1.46.0")]
+impl From<char> for String {
+ #[inline]
+ fn from(c: char) -> Self {
+ c.to_string()
+ }
+}

src/liballoc/tests/string.rs

@@ -714,3 +714,10 @@ fn test_try_reserve_exact() {
  }
  }
 }
+
+#[test]
+fn test_from_char() {
+ assert_eq!(String::from('a'), 'a'.to_string());
+ let s: String = 'x'.into();
+ assert_eq!(s, 'x'.to_string());
+}

src/libcore/intrinsics.rs

@@ -952,6 +952,7 @@ extern "rust-intrinsic" {
  /// Any use other than with `if` statements will probably not have an effect.
  ///
  /// This intrinsic does not have a stable counterpart.
+ #[rustc_const_unstable(feature = "const_likely", issue = "none")]
  pub fn likely(b: bool) -> bool;
 
  /// Hints to the compiler that branch condition is likely to be false.
@@ -960,6 +961,7 @@ extern "rust-intrinsic" {
  /// Any use other than with `if` statements will probably not have an effect.
  ///
  /// This intrinsic does not have a stable counterpart.
+ #[rustc_const_unstable(feature = "const_likely", issue = "none")]
  pub fn unlikely(b: bool) -> bool;
 
  /// Executes a breakpoint trap, for inspection by a debugger.

src/libcore/lib.rs

@@ -92,6 +92,7 @@
 #![feature(const_slice_from_raw_parts)]
 #![feature(const_slice_ptr_len)]
 #![feature(const_type_name)]
+#![feature(const_likely)]
 #![feature(custom_inner_attributes)]
 #![feature(decl_macro)]
 #![feature(doc_cfg)]
@@ -118,7 +119,7 @@
 #![feature(staged_api)]
 #![feature(std_internals)]
 #![feature(stmt_expr_attributes)]
-#![feature(track_caller)]
+#![cfg_attr(bootstrap, feature(track_caller))]
 #![feature(transparent_unions)]
 #![feature(unboxed_closures)]
 #![feature(unsized_locals)]

src/libcore/macros/mod.rs

@@ -1,6 +1,6 @@
 #[doc(include = "panic.md")]
 #[macro_export]
-#[allow_internal_unstable(core_panic, track_caller)]
+#[allow_internal_unstable(core_panic, const_caller_location)]
 #[stable(feature = "core", since = "1.6.0")]
 macro_rules! panic {
  () => (

src/libcore/panic.rs

@@ -190,7 +190,6 @@ impl<'a> Location<'a> {
  /// # Examples
  ///
  /// ```
- /// #![feature(track_caller)]
  /// use core::panic::Location;
  ///
  /// /// Returns the [`Location`] at which it is called.
@@ -206,7 +205,7 @@ impl<'a> Location<'a> {
  ///
  /// let fixed_location = get_just_one_location();
  /// assert_eq!(fixed_location.file(), file!());
- /// assert_eq!(fixed_location.line(), 15);
+ /// assert_eq!(fixed_location.line(), 14);
  /// assert_eq!(fixed_location.column(), 5);
  ///
  /// // running the same untracked function in a different location gives us the same result
@@ -217,7 +216,7 @@ impl<'a> Location<'a> {
  ///
  /// let this_location = get_caller_location();
  /// assert_eq!(this_location.file(), file!());
- /// assert_eq!(this_location.line(), 29);
+ /// assert_eq!(this_location.line(), 28);
  /// assert_eq!(this_location.column(), 21);
  ///
  /// // running the tracked function in a different location produces a different value
@@ -226,13 +225,8 @@ impl<'a> Location<'a> {
  /// assert_ne!(this_location.line(), another_location.line());
  /// assert_ne!(this_location.column(), another_location.column());
  /// ```
- // FIXME: When stabilizing this method, please also update the documentation
- // of `intrinsics::caller_location`.
- #[unstable(
- feature = "track_caller",
- reason = "uses #[track_caller] which is not yet stable",
- issue = "47809"
- )]
+ #[stable(feature = "track_caller", since = "1.46.0")]
+ #[rustc_const_unstable(feature = "const_caller_location", issue = "47809")]
  #[track_caller]
  pub const fn caller() -> &'static Location<'static> {
  crate::intrinsics::caller_location()

src/librustc_ast_pretty/pprust.rs

@@ -9,7 +9,7 @@ use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_ast::attr;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, BinOpToken, DelimToken, Nonterminal, Token, TokenKind};
-use rustc_ast::tokenstream::{self, TokenStream, TokenTree};
+use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_ast::util::parser::{self, AssocOp, Fixity};
 use rustc_ast::util::{classify, comments};
 use rustc_span::edition::Edition;
@@ -293,7 +293,7 @@ pub fn nonterminal_to_string(nt: &Nonterminal) -> String {
  token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(e, is_raw).to_string(),
  token::NtLifetime(e) => e.to_string(),
  token::NtLiteral(ref e) => expr_to_string(e),
- token::NtTT(ref tree) => tt_to_string(tree.clone()),
+ token::NtTT(ref tree) => tt_to_string(tree),
  token::NtVis(ref e) => vis_to_string(e),
  }
 }
@@ -314,11 +314,11 @@ pub fn expr_to_string(e: &ast::Expr) -> String {
  to_string(|s| s.print_expr(e))
 }
 
-pub fn tt_to_string(tt: tokenstream::TokenTree) -> String {
+pub fn tt_to_string(tt: &TokenTree) -> String {
  to_string(|s| s.print_tt(tt, false))
 }
 
-pub fn tts_to_string(tokens: TokenStream) -> String {
+pub fn tts_to_string(tokens: &TokenStream) -> String {
  to_string(|s| s.print_tts(tokens, false))
 }
 
@@ -585,7 +585,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  false,
  None,
  delim.to_token(),
- tokens.clone(),
+ tokens,
  true,
  span,
  ),
@@ -594,7 +594,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  if let MacArgs::Eq(_, tokens) = &item.args {
  self.space();
  self.word_space("=");
- self.print_tts(tokens.clone(), true);
+ self.print_tts(tokens, true);
  }
  }
  }
@@ -635,9 +635,9 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  /// appropriate macro, transcribe back into the grammar we just parsed from,
  /// and then pretty-print the resulting AST nodes (so, e.g., we print
  /// expression arguments as expressions). It can be done! I think.
- fn print_tt(&mut self, tt: tokenstream::TokenTree, convert_dollar_crate: bool) {
+ fn print_tt(&mut self, tt: &TokenTree, convert_dollar_crate: bool) {
  match tt {
- TokenTree::Token(ref token) => {
+ TokenTree::Token(token) => {
  self.word(token_to_string_ext(&token, convert_dollar_crate));
  if let token::DocComment(..) = token.kind {
  self.hardbreak()
@@ -648,7 +648,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  None,
  false,
  None,
- delim,
+ *delim,
  tts,
  convert_dollar_crate,
  dspan.entire(),
@@ -657,14 +657,14 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  }
  }
 
- fn print_tts(&mut self, tts: tokenstream::TokenStream, convert_dollar_crate: bool) {
- let mut iter = tts.into_trees().peekable();
+ fn print_tts(&mut self, tts: &TokenStream, convert_dollar_crate: bool) {
+ let mut iter = tts.trees().peekable();
  while let Some(tt) = iter.next() {
- let show_space =
-  if let Some(next) = iter.peek() { tt_prepend_space(next, &tt) } else { false };
- self.print_tt(tt, convert_dollar_crate);
- if show_space {
- self.space();
+ self.print_tt(&tt, convert_dollar_crate);
+ if let Some(next) = iter.peek() {
+  if tt_prepend_space(next, &tt) {
+  self.space();
+ }
  }
  }
  }
@@ -675,7 +675,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  has_bang: bool,
  ident: Option<Ident>,
  delim: DelimToken,
- tts: TokenStream,
+ tts: &TokenStream,
  convert_dollar_crate: bool,
  span: Span,
  ) {
@@ -1253,7 +1253,7 @@ impl<'a> State<'a> {
  has_bang,
  Some(item.ident),
  macro_def.body.delim(),
- macro_def.body.inner_tokens(),
+ &macro_def.body.inner_tokens(),
  true,
  item.span,
  );
@@ -1577,7 +1577,7 @@ impl<'a> State<'a> {
  true,
  None,
  m.args.delim(),
- m.args.inner_tokens(),
+ &m.args.inner_tokens(),
  true,
  m.span(),
  );

src/librustc_builtin_macros/log_syntax.rs

@@ -7,7 +7,7 @@ pub fn expand_log_syntax<'cx>(
  sp: rustc_span::Span,
  tts: TokenStream,
 ) -> Box<dyn base::MacResult + 'cx> {
- println!("{}", pprust::tts_to_string(tts));
+ println!("{}", pprust::tts_to_string(&tts));
 
  // any so that `log_syntax` can be invoked as an expression and item.
  base::DummyResult::any_valid(sp)

src/librustc_builtin_macros/source_util.rs

@@ -71,7 +71,7 @@ pub fn expand_stringify(
  tts: TokenStream,
 ) -> Box<dyn base::MacResult + 'static> {
  let sp = cx.with_def_site_ctxt(sp);
- let s = pprust::tts_to_string(tts);
+ let s = pprust::tts_to_string(&tts);
  base::MacEager::expr(cx.expr_str(sp, Symbol::intern(&s)))
 }
 

src/librustc_error_codes/error_codes/E0736.md

@@ -3,8 +3,6 @@
 Erroneous code example:
 
 ```compile_fail,E0736
-#![feature(track_caller)]
-
 #[naked]
 #[track_caller]
 fn foo() {}

src/librustc_error_codes/error_codes/E0737.md

@@ -5,8 +5,6 @@ restrictions.
 Erroneous code example:
 
 ```compile_fail,E0737
-#![feature(track_caller)]
-
 #[track_caller]
 extern "C" fn foo() {}
 ```

src/librustc_error_codes/error_codes/E0739.md

@@ -3,7 +3,6 @@
 Erroneous code example:
 
 ```compile_fail,E0739
-#![feature(track_caller)]
 #[track_caller]
 struct Bar {
  a: u8,

src/librustc_errors/lib.rs

@@ -5,7 +5,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
 #![feature(crate_visibility_modifier)]
 #![feature(nll)]
-#![feature(track_caller)]
+#![cfg_attr(bootstrap, feature(track_caller))]
 
 pub use emitter::ColorConfig;
 

src/librustc_expand/mbe/macro_rules.rs

@@ -224,7 +224,7 @@ fn generic_extension<'cx>(
  let sess = cx.parse_sess;
 
  if cx.trace_macros() {
- let msg = format!("expanding `{}! {{ {} }}`", name, pprust::tts_to_string(arg.clone()));
+ let msg = format!("expanding `{}! {{ {} }}`", name, pprust::tts_to_string(&arg));
  trace_macros_note(&mut cx.expansions, sp, msg);
  }
 
@@ -300,7 +300,7 @@ fn generic_extension<'cx>(
  }
 
  if cx.trace_macros() {
- let msg = format!("to `{}`", pprust::tts_to_string(tts.clone()));
+ let msg = format!("to `{}`", pprust::tts_to_string(&tts));
  trace_macros_note(&mut cx.expansions, sp, msg);
  }
 

src/librustc_expand/proc_macro_server.rs

@@ -413,7 +413,7 @@ impl server::TokenStream for Rustc<'_> {
  )
  }
  fn to_string(&mut self, stream: &Self::TokenStream) -> String {
- pprust::tts_to_string(stream.clone())
+ pprust::tts_to_string(stream)
  }
  fn from_token_tree(
  &mut self,

src/librustc_feature/accepted.rs

@@ -265,6 +265,9 @@ declare_features! (
  (accepted, const_if_match, "1.45.0", Some(49146), None),
  /// Allows the use of `loop` and `while` in constants.
  (accepted, const_loop, "1.45.0", Some(52000), None),
+ /// Allows `#[track_caller]` to be used which provides
+ /// accurate caller location reporting during panic (RFC 2091).
+ (accepted, track_caller, "1.46.0", Some(47809), None),
 
  // -------------------------------------------------------------------------
  // feature-group-end: accepted features

src/librustc_feature/active.rs

@@ -494,10 +494,6 @@ declare_features! (
  /// Allows the use of raw-dylibs (RFC 2627).
  (active, raw_dylib, "1.40.0", Some(58713), None),
 
- /// Allows `#[track_caller]` to be used which provides
- /// accurate caller location reporting during panic (RFC 2091).
- (active, track_caller, "1.40.0", Some(47809), None),
-
  /// Allows making `dyn Trait` well-formed even if `Trait` is not object safe.
  /// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and
  /// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden.