Rollup of 12 pull requests

Cargo.toml

@@ -33,16 +33,16 @@ exclude = [
  "obj",
 ]
 
-# These options are controlled from our rustc wrapper script, so turn them off
-# here and have them controlled elsewhere.
-[profile.dev]
-debug = false
-debug-assertions = false
-[profile.test]
-debug = false
+[profile.release.package.compiler_builtins]
+# The compiler-builtins crate cannot reference libcore, and it's own CI will
+# verify that this is the case. This requires, however, that the crate is built
+# without overflow checks and debug assertions. Forcefully disable debug
+# assertions and overflow checks here which should ensure that even if these
+# assertions are enabled for libstd we won't enable then for compiler_builtins
+# which should ensure we still link everything correctly.
 debug-assertions = false
+overflow-checks = false
 
-[profile.release.package.compiler_builtins]
 # For compiler-builtins we always use a high number of codegen units.
 # The goal here is to place every single intrinsic into its own object
 # file to avoid symbol clashes with the system libgcc if possible. Note

config.toml.example

@@ -378,7 +378,7 @@
 # nightly features
 #channel = "dev"
 
-# The root location of the MUSL installation directory.
+# The root location of the musl installation directory.
 #musl-root = "..."
 
 # By default the `rustc` executable is built with `-Wl,-rpath` flags on Unix
@@ -521,12 +521,15 @@
 # only use static libraries. If unset, the target's default linkage is used.
 #crt-static = false
 
-# The root location of the MUSL installation directory. The library directory
+# The root location of the musl installation directory. The library directory
 # will also need to contain libunwind.a for an unwinding implementation. Note
-# that this option only makes sense for MUSL targets that produce statically
+# that this option only makes sense for musl targets that produce statically
 # linked binaries
 #musl-root = "..."
 
+# The full path to the musl libdir.
+#musl-libdir = musl-root/lib
+
 # The root location of the `wasm32-wasi` sysroot.
 #wasi-root = "..."
 

src/bootstrap/bin/rustc.rs

@@ -101,30 +101,6 @@ fn main() {
  {
  cmd.arg("-C").arg("panic=abort");
  }
-
- // Set various options from config.toml to configure how we're building
- // code.
- let debug_assertions = match env::var("RUSTC_DEBUG_ASSERTIONS") {
- Ok(s) => {
- if s == "true" {
- "y"
- } else {
- "n"
- }
- }
- Err(..) => "n",
- };
-
- // The compiler builtins are pretty sensitive to symbols referenced in
- // libcore and such, so we never compile them with debug assertions.
- //
- // FIXME(rust-lang/cargo#7253) we should be doing this in `builder.rs`
- // with env vars instead of doing it here in this script.
- if crate_name == Some("compiler_builtins") {
- cmd.arg("-C").arg("debug-assertions=no");
- } else {
- cmd.arg("-C").arg(format!("debug-assertions={}", debug_assertions));
- }
  } else {
  // FIXME(rust-lang/cargo#5754) we shouldn't be using special env vars
  // here, but rather Cargo should know what flags to pass rustc itself.

src/bootstrap/builder.rs

@@ -950,14 +950,6 @@ impl<'a> Builder<'a> {
  .env("RUSTC", self.out.join("bootstrap/debug/rustc"))
  .env("RUSTC_REAL", self.rustc(compiler))
  .env("RUSTC_STAGE", stage.to_string())
- .env(
- "RUSTC_DEBUG_ASSERTIONS",
- if mode == Mode::Std {
- self.config.rust_debug_assertions_std.to_string()
- } else {
- self.config.rust_debug_assertions.to_string()
- },
- )
  .env("RUSTC_SYSROOT", &sysroot)
  .env("RUSTC_LIBDIR", &libdir)
  .env("RUSTDOC", self.out.join("bootstrap/debug/rustdoc"))
@@ -1041,6 +1033,14 @@ impl<'a> Builder<'a> {
  }
  };
  cargo.env(profile_var("DEBUG"), debuginfo_level.to_string());
+ cargo.env(
+ profile_var("DEBUG_ASSERTIONS"),
+ if mode == Mode::Std {
+ self.config.rust_debug_assertions_std.to_string()
+ } else {
+ self.config.rust_debug_assertions.to_string()
+ },
+ );
 
  if !mode.is_tool() {
  cargo.env("RUSTC_FORCE_UNSTABLE", "1");

src/bootstrap/compile.rs

@@ -177,7 +177,7 @@ fn copy_self_contained_objects(
  // To do that we have to distribute musl startup objects as a part of Rust toolchain
  // and link with them manually in the self-contained mode.
  if target.contains("musl") {
- let srcdir = builder.musl_root(target).unwrap().join("lib");
+ let srcdir = builder.musl_libdir(target).unwrap();
  for &obj in &["crt1.o", "Scrt1.o", "rcrt1.o", "crti.o", "crtn.o"] {
  copy_and_stamp(
  builder,
@@ -266,8 +266,8 @@ pub fn std_cargo(builder: &Builder<'_>, target: Interned<String>, stage: u32, ca
  // Help the libc crate compile by assisting it in finding various
  // sysroot native libraries.
  if target.contains("musl") {
- if let Some(p) = builder.musl_root(target) {
- let root = format!("native={}/lib", p.to_str().unwrap());
+ if let Some(p) = builder.musl_libdir(target) {
+ let root = format!("native={}", p.to_str().unwrap());
  cargo.rustflag("-L").rustflag(&root);
  }
  }

src/bootstrap/config.rs

@@ -173,6 +173,7 @@ pub struct Target {
  pub ndk: Option<PathBuf>,
  pub crt_static: Option<bool>,
  pub musl_root: Option<PathBuf>,
+ pub musl_libdir: Option<PathBuf>,
  pub wasi_root: Option<PathBuf>,
  pub qemu_rootfs: Option<PathBuf>,
  pub no_std: bool,
@@ -363,6 +364,7 @@ struct TomlTarget {
  android_ndk: Option<String>,
  crt_static: Option<bool>,
  musl_root: Option<String>,
+ musl_libdir: Option<String>,
  wasi_root: Option<String>,
  qemu_rootfs: Option<String>,
  no_std: Option<bool>,
@@ -631,6 +633,7 @@ impl Config {
  target.linker = cfg.linker.clone().map(PathBuf::from);
  target.crt_static = cfg.crt_static;
  target.musl_root = cfg.musl_root.clone().map(PathBuf::from);
+ target.musl_libdir = cfg.musl_libdir.clone().map(PathBuf::from);
  target.wasi_root = cfg.wasi_root.clone().map(PathBuf::from);
  target.qemu_rootfs = cfg.qemu_rootfs.clone().map(PathBuf::from);
 

src/bootstrap/lib.rs

@@ -888,6 +888,15 @@ impl Build {
  .map(|p| &**p)
  }
 
+ /// Returns the "musl libdir" for this `target`.
+ fn musl_libdir(&self, target: Interned<String>) -> Option<PathBuf> {
+ let t = self.config.target_config.get(&target)?;
+ if let libdir @ Some(_) = &t.musl_libdir {
+ return libdir.clone();
+ }
+ self.musl_root(target).map(|root| root.join("lib"))
+ }
+
  /// Returns the sysroot for the wasi target, if defined
  fn wasi_root(&self, target: Interned<String>) -> Option<&Path> {
  self.config.target_config.get(&target).and_then(|t| t.wasi_root.as_ref()).map(|p| &**p)

src/bootstrap/sanity.rs

@@ -199,10 +199,10 @@ pub fn check(build: &mut Build) {
  let target = build.config.target_config.entry(target.clone()).or_default();
  target.musl_root = Some("/usr".into());
  }
- match build.musl_root(*target) {
- Some(root) => {
- if fs::metadata(root.join("lib/libc.a")).is_err() {
- panic!("couldn't find libc.a in musl dir: {}", root.join("lib").display());
+ match build.musl_libdir(*target) {
+ Some(libdir) => {
+ if fs::metadata(libdir.join("libc.a")).is_err() {
+ panic!("couldn't find libc.a in musl libdir: {}", libdir.display());
  }
  }
  None => panic!(

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/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_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_interface/tests.rs

@@ -500,7 +500,6 @@ fn test_debugging_options_tracking_hash() {
  untracked!(print_link_args, true);
  untracked!(print_llvm_passes, true);
  untracked!(print_mono_items, Some(String::from("abc")));
- untracked!(print_region_graph, true);
  untracked!(print_type_sizes, true);
  untracked!(query_dep_graph, true);
  untracked!(query_stats, true);

src/librustc_mir/borrow_check/diagnostics/region_errors.rs

@@ -122,7 +122,9 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  if self.regioncx.universal_regions().is_universal_region(r) {
  Some(r)
  } else {
- let upper_bound = self.regioncx.universal_upper_bound(r);
+ // We just want something nameable, even if it's not
+ // actually an upper bound.
+ let upper_bound = self.regioncx.approx_universal_upper_bound(r);
 
  if self.regioncx.upper_bound_in_region_scc(r, upper_bound) {
  self.to_error_region_vid(upper_bound)