Rollup of 14 pull requests

config.toml.example

@@ -164,6 +164,9 @@
 # Python interpreter to use for various tasks throughout the build, notably
 # rustdoc tests, the lldb python interpreter, and some dist bits and pieces.
 # Note that Python 2 is currently required.
+#
+# Defaults to python2.7, then python2. If neither executable can be found, then
+# it defaults to the Python interpreter used to execute x.py.
 #python = "python2.7"
 
 # Force Cargo to check that Cargo.lock describes the precise dependency

src/bootstrap/config.rs

@@ -650,6 +650,22 @@ impl Config {
  let default = config.channel == "dev";
  config.ignore_git = ignore_git.unwrap_or(default);
 
+ // Disable should_panic tests on Android targets. Panic in tests currently means a potential
+ // segfault could occur on Android, which will spuriously fail our CI.
+ //
+ // See #55861 for more information.
+ if config.targets.iter().any(|target| target.contains("android")) {
+ if let Subcommand::Test { test_args, .. } |
+ Subcommand::Bench { test_args, .. } = &mut config.cmd {
+ if !test_args.contains(&String::from("-Zunstable-options")) {
+ test_args.push(String::from("-Zunstable-options"));
+ }
+ if !test_args.contains(&String::from("--exclude-should-panic")) {
+ test_args.push(String::from("--exclude-should-panic"));
+ }
+ }
+ }
+
  config
  }
 

src/bootstrap/sanity.rs

@@ -34,15 +34,17 @@ impl Finder {
 
  fn maybe_have<S: AsRef<OsStr>>(&mut self, cmd: S) -> Option<PathBuf> {
  let cmd: OsString = cmd.as_ref().into();
- let path = self.path.clone();
+ let path = &self.path;
  self.cache.entry(cmd.clone()).or_insert_with(|| {
- for path in env::split_paths(&path) {
+ for path in env::split_paths(path) {
  let target = path.join(&cmd);
- let mut cmd_alt = cmd.clone();
- cmd_alt.push(".exe");
- if target.is_file() || // some/path/git
- target.with_extension("exe").exists() || // some/path/git.exe
- target.join(&cmd_alt).exists() { // some/path/git/git.exe
+ let mut cmd_exe = cmd.clone();
+ cmd_exe.push(".exe");
+
+ if target.is_file() // some/path/git
+ || path.join(&cmd_exe).exists() // some/path/git.exe
+ || target.join(&cmd_exe).exists() // some/path/git/git.exe
+ {
  return Some(target);
  }
  }
@@ -107,9 +109,9 @@ pub fn check(build: &mut Build) {
  }
 
  build.config.python = build.config.python.take().map(|p| cmd_finder.must_have(p))
- .or_else(|| env::var_os("BOOTSTRAP_PYTHON").map(PathBuf::from)) // set by bootstrap.py
  .or_else(|| cmd_finder.maybe_have("python2.7"))
  .or_else(|| cmd_finder.maybe_have("python2"))
+ .or_else(|| env::var_os("BOOTSTRAP_PYTHON").map(PathBuf::from)) // set by bootstrap.py
  .or_else(|| Some(cmd_finder.must_have("python")));
 
  build.config.nodejs = build.config.nodejs.take().map(|p| cmd_finder.must_have(p))

src/doc/rustdoc/src/unstable-features.md

@@ -53,7 +53,7 @@ For example, in the following code:
 ```rust
 /// Does the thing.
 pub fn do_the_thing(_: SomeType) {
- println!("Let's do the thing!");
+ println!("Let's do the thing!");
 }
 
 /// Token you use to [`do_the_thing`].
@@ -66,15 +66,15 @@ target out also works:
 
 ```rust
 pub mod some_module {
- /// Token you use to do the thing.
- pub struct SomeStruct;
+ /// Token you use to do the thing.
+ pub struct SomeStruct;
 }
 
 /// Does the thing. Requires one [`SomeStruct`] for the thing to work.
 ///
 /// [`SomeStruct`]: some_module::SomeStruct
 pub fn do_the_thing(_: some_module::SomeStruct) {
- println!("Let's do the thing!");
+ println!("Let's do the thing!");
 }
 ```
 
@@ -428,3 +428,30 @@ $ rustdoc src/lib.rs --test -Z unstable-options --persist-doctests target/rustdo
 This flag allows you to keep doctest executables around after they're compiled or run.
 Usually, rustdoc will immediately discard a compiled doctest after it's been tested, but
 with this option, you can keep those binaries around for farther testing.
+
+### `--show-coverage`: calculate the percentage of items with documentation
+
+Using this flag looks like this:
+
+```bash
+$ rustdoc src/lib.rs -Z unstable-options --show-coverage
+```
+
+If you want to determine how many items in your crate are documented, pass this flag to rustdoc.
+When it receives this flag, it will count the public items in your crate that have documentation,
+and print out the counts and a percentage instead of generating docs.
+
+Some methodology notes about what rustdoc counts in this metric:
+
+* Rustdoc will only count items from your crate (i.e. items re-exported from other crates don't
+ count).
+* Docs written directly onto inherent impl blocks are not counted, even though their doc comments
+ are displayed, because the common pattern in Rust code is to write all inherent methods into the
+ same impl block.
+* Items in a trait implementation are not counted, as those impls will inherit any docs from the
+ trait itself.
+* By default, only public items are counted. To count private items as well, pass
+ `--document-private-items` at the same time.
+
+Public items that are not documented can be seen with the built-in `missing_docs` lint. Private
+items that are not documented can be seen with Clippy's `missing_docs_in_private_items` lint.

src/etc/lldb_rust_formatters.py

@@ -290,6 +290,8 @@ def render_element(i):
 
 
 def read_utf8_string(ptr_val, byte_count):
+ if byte_count == 0:
+ return '""'
  error = lldb.SBError()
  process = ptr_val.get_wrapped_value().GetProcess()
  data = process.ReadMemory(ptr_val.as_integer(), byte_count, error)

src/liballoc/vec.rs

@@ -2468,6 +2468,25 @@ impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> {
  }
 }
 
+impl<'a, T> Drain<'a, T> {
+ /// Returns the remaining items of this iterator as a slice.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #![feature(vec_drain_as_slice)]
+ /// let mut vec = vec!['a', 'b', 'c'];
+ /// let mut drain = vec.drain(..);
+ /// assert_eq!(drain.as_slice(), &['a', 'b', 'c']);
+ /// let _ = drain.next().unwrap();
+ /// assert_eq!(drain.as_slice(), &['b', 'c']);
+ /// ```
+ #[unstable(feature = "vec_drain_as_slice", reason = "recently added", issue = "58957")]
+ pub fn as_slice(&self) -> &[T] {
+ self.iter.as_slice()
+ }
+}
+
 #[stable(feature = "drain", since = "1.6.0")]
 unsafe impl<T: Sync> Sync for Drain<'_, T> {}
 #[stable(feature = "drain", since = "1.6.0")]

src/libcore/fmt/float.rs

@@ -15,6 +15,7 @@ fn float_to_decimal_common_exact<T>(fmt: &mut Formatter, num: &T,
  // FIXME(#53491): Technically, this is calling `get_mut` on an uninitialized
  // `MaybeUninit` (here and elsewhere in this file). Revisit this once
  // we decided whether that is valid or not.
+ // Using `freeze` is *not enough*; `flt2dec::Part` is an enum!
  let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,
  *num, sign, precision,
  false, buf.get_mut(), parts.get_mut());
@@ -33,6 +34,7 @@ fn float_to_decimal_common_shortest<T>(fmt: &mut Formatter, num: &T,
  // enough for f32 and f64
  let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
  let mut parts = MaybeUninit::<[flt2dec::Part; 4]>::uninitialized();
+ // FIXME(#53491)
  let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num,
  sign, precision, false, buf.get_mut(),
  parts.get_mut());
@@ -71,6 +73,7 @@ fn float_to_exponential_common_exact<T>(fmt: &mut Formatter, num: &T,
  unsafe {
  let mut buf = MaybeUninit::<[u8; 1024]>::uninitialized(); // enough for f32 and f64
  let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
+ // FIXME(#53491)
  let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact,
  *num, sign, precision,
  upper, buf.get_mut(), parts.get_mut());
@@ -90,6 +93,7 @@ fn float_to_exponential_common_shortest<T>(fmt: &mut Formatter,
  // enough for f32 and f64
  let mut buf = MaybeUninit::<[u8; flt2dec::MAX_SIG_DIGITS]>::uninitialized();
  let mut parts = MaybeUninit::<[flt2dec::Part; 6]>::uninitialized();
+ // FIXME(#53491)
  let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest,
  *num, sign, (0, 0), upper,
  buf.get_mut(), parts.get_mut());