Rollup of 6 pull requests

RELEASES.md

@@ -1,4 +1,4 @@
-Rust 1.56.0 (2021-10-21)
+Version 1.56.0 (2021-10-21)
 ========================
 
 Language
@@ -22,6 +22,7 @@ Compiler
  This feature is primarily intended for usage by `cargo fix`, rather than end users.
 - [Promote `aarch64-apple-ios-sim` to Tier 2\*.][rust#87760]
 - [Add `powerpc-unknown-freebsd` at Tier 3\*.][rust#87370]
+- [Add `riscv32imc-esp-espidf` at Tier 3\*.][rust#87666]
 
 \* Refer to Rust's [platform support page][platform-support-doc] for more
 information on Rust's tiered platform support.
@@ -180,6 +181,7 @@ and related tools.
 [rust#87619]: https://github.com/rust-lang/rust/pull/87619
 [rust#81825]: https://github.com/rust-lang/rust/pull/81825#issuecomment-808406918
 [rust#88019]: https://github.com/rust-lang/rust/pull/88019
+[rust#87666]: https://github.com/rust-lang/rust/pull/87666
 
 Version 1.55.0 (2021-09-09)
 ============================

compiler/rustc_resolve/src/diagnostics.rs

@@ -1277,6 +1277,34 @@ impl<'a> Resolver<'a> {
 
  err.emit();
  }
+
+ crate fn find_similarly_named_module_or_crate(
+ &mut self,
+ ident: Symbol,
+ current_module: &Module<'a>,
+ ) -> Option<Symbol> {
+ let mut candidates = self
+ .extern_prelude
+ .iter()
+ .map(|(ident, _)| ident.name)
+ .chain(
+ self.module_map
+ .iter()
+ .filter(|(_, module)| {
+ current_module.is_ancestor_of(module) && !ptr::eq(current_module, *module)
+ })
+ .map(|(_, module)| module.kind.name())
+ .flatten(),
+ )
+ .filter(|c| !c.to_string().is_empty())
+ .collect::<Vec<_>>();
+ candidates.sort();
+ candidates.dedup();
+ match find_best_match_for_name(&candidates, ident, None) {
+ Some(sugg) if sugg == ident => None,
+ sugg => sugg,
+ }
+ }
 }
 
 impl<'a, 'b> ImportResolver<'a, 'b> {

compiler/rustc_resolve/src/lib.rs

@@ -2555,7 +2555,22 @@ impl<'a> Resolver<'a> {
 
  (format!("use of undeclared type `{}`", ident), suggestion)
  } else {
- (format!("use of undeclared crate or module `{}`", ident), None)
+ (
+ format!("use of undeclared crate or module `{}`", ident),
+ self.find_similarly_named_module_or_crate(
+ ident.name,
+ &parent_scope.module,
+ )
+ .map(|sugg| {
+ (
+ vec![(ident.span, sugg.to_string())],
+ String::from(
+ "there is a crate or module with a similar name",
+ ),
+ Applicability::MaybeIncorrect,
+ )
+ }),
+ )
  }
  } else {
  let parent = path[i - 1].ident.name;

library/std/src/thread/mod.rs

@@ -1428,39 +1428,76 @@ fn _assert_sync_and_send() {
  _assert_both::<Thread>();
 }
 
-/// Returns the number of hardware threads available to the program.
-///
-/// This value should be considered only a hint.
-///
-/// # Platform-specific behavior
-///
-/// If interpreted as the number of actual hardware threads, it may undercount on
-/// Windows systems with more than 64 hardware threads. If interpreted as the
-/// available concurrency for that process, it may overcount on Windows systems
-/// when limited by a process wide affinity mask or job object limitations, and
-/// it may overcount on Linux systems when limited by a process wide affinity
-/// mask or affected by cgroups limits.
+/// Returns an estimate of the default amount of parallelism a program should use.
+///
+/// Parallelism is a resource. A given machine provides a certain capacity for
+/// parallelism, i.e., a bound on the number of computations it can perform
+/// simultaneously. This number often corresponds to the amount of CPUs or
+/// computer has, but it may diverge in various cases.
+///
+/// Host environments such as VMs or container orchestrators may want to
+/// restrict the amount of parallelism made available to programs in them. This
+/// is often done to limit the potential impact of (unintentionally)
+/// resource-intensive programs on other programs running on the same machine.
+///
+/// # Limitations
+///
+/// The purpose of this API is to provide an easy and portable way to query
+/// the default amount of parallelism the program should use. Among other things it
+/// does not expose information on NUMA regions, does not account for
+/// differences in (co)processor capabilities, and will not modify the program's
+/// global state in order to more accurately query the amount of available
+/// parallelism.
+///
+/// The value returned by this function should be considered a simplified
+/// approximation of the actual amount of parallelism available at any given
+/// time. To get a more detailed or precise overview of the amount of
+/// parallelism available to the program, you may wish to use
+/// platform-specific APIs as well. The following platform limitations currently
+/// apply to `available_parallelism`:
+///
+/// On Windows:
+/// - It may undercount the amount of parallelism available on systems with more
+/// than 64 logical CPUs. However, programs typically need specific support to
+/// take advantage of more than 64 logical CPUs, and in the absence of such
+/// support, the number returned by this function accurately reflects the
+/// number of logical CPUs the program can use by default.
+/// - It may overcount the amount of parallelism available on systems limited by
+/// process-wide affinity masks, or job object limitations.
+///
+/// On Linux:
+/// - It may overcount the amount of parallelism available when limited by a
+/// process-wide affinity mask, or when affected by cgroup limits.
+///
+/// On all targets:
+/// - It may overcount the amount of parallelism available when running in a VM
+/// with CPU usage limits (e.g. an overcommitted host).
 ///
 /// # Errors
 ///
-/// This function will return an error in the following situations, but is not
-/// limited to just these cases:
+/// This function will, but is not limited to, return errors in the following
+/// cases:
 ///
-/// - If the number of hardware threads is not known for the target platform.
-/// - The process lacks permissions to view the number of hardware threads
-/// available.
+/// - If the amount of parallelism is not known for the target platform.
+/// - If the program lacks permission to query the amount of parallelism made
+/// available to it.
 ///
 /// # Examples
 ///
 /// ```
 /// # #![allow(dead_code)]
 /// #![feature(available_parallelism)]
-/// use std::thread;
+/// use std::{io, thread};
 ///
-/// let count = thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
+/// fn main() -> io::Result<()> {
+/// let count = thread::available_parallelism()?.get();
+/// assert!(count >= 1_usize);
+/// Ok(())
+/// }
 /// ```
+#[doc(alias = "available_concurrency")] // Alias for a previous name we gave this API on unstable.
 #[doc(alias = "hardware_concurrency")] // Alias for C++ `std::thread::hardware_concurrency`.
-#[doc(alias = "available_concurrency")] // Alias for a name we gave this API on unstable.
+#[doc(alias = "num_cpus")] // Alias for a popular ecosystem crate which provides similar functionality.
 #[unstable(feature = "available_parallelism", issue = "74479")]
 pub fn available_parallelism() -> io::Result<NonZeroUsize> {
  imp::available_parallelism()

src/bootstrap/bootstrap.py

@@ -1001,7 +1001,7 @@ def update_submodule(self, module, checked_out, recorded_submodules):
  run(["git", "submodule", "-q", "sync", module],
  cwd=self.rust_root, verbose=self.verbose)
 
- update_args = ["git", "submodule", "update", "--init", "--recursive"]
+ update_args = ["git", "submodule", "update", "--init", "--recursive", "--depth=1"]
  if self.git_version >= distutils.version.LooseVersion("2.11.0"):
  update_args.append("--progress")
  update_args.append(module)

src/bootstrap/builder.rs

@@ -370,7 +370,7 @@ impl<'a> Builder<'a> {
  match kind {
  Kind::Build => describe!(
  compile::Std,
- compile::Rustc,
+ compile::Assemble,
  compile::CodegenBackend,
  compile::StartupObjects,
  tool::BuildManifest,

src/bootstrap/compile.rs

@@ -528,7 +528,7 @@ impl Step for Rustc {
  const DEFAULT: bool = false;
 
  fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- run.path("compiler/rustc")
+ run.never()
  }
 
  fn make_run(run: RunConfig<'_>) {
@@ -1023,9 +1023,16 @@ pub struct Assemble {
 
 impl Step for Assemble {
  type Output = Compiler;
+ const ONLY_HOSTS: bool = true;
 
  fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- run.never()
+ run.path("compiler/rustc")
+ }
+
+ fn make_run(run: RunConfig<'_>) {
+ run.builder.ensure(Assemble {
+ target_compiler: run.builder.compiler(run.builder.top_stage + 1, run.target),
+ });
  }
 
  /// Prepare a new compiler from the artifacts in `stage`

src/test/ui/macros/macro-inner-attributes.stderr

@@ -3,6 +3,11 @@ error[E0433]: failed to resolve: use of undeclared crate or module `a`
  |
 LL | a::bar();
  | ^ use of undeclared crate or module `a`
+ |
+help: there is a crate or module with a similar name
+ |
+LL | b::bar();
+ | ~
 
 error: aborting due to previous error
 

src/test/ui/suggestions/crate-or-module-typo.rs

@@ -0,0 +1,17 @@
+// edition:2018
+
+use st::cell::Cell; //~ ERROR failed to resolve: use of undeclared crate or module `st`
+
+mod bar {
+ pub fn bar() { bar::baz(); } //~ ERROR failed to resolve: use of undeclared crate or module `bar`
+
+ fn baz() {}
+}
+
+use bas::bar; //~ ERROR unresolved import `bas`
+
+struct Foo {
+ bar: st::cell::Cell<bool> //~ ERROR failed to resolve: use of undeclared crate or module `st`
+}
+
+fn main() {}

src/test/ui/suggestions/crate-or-module-typo.stderr

@@ -0,0 +1,43 @@
+error[E0433]: failed to resolve: use of undeclared crate or module `st`
+ --> $DIR/crate-or-module-typo.rs:3:5
+ |
+LL | use st::cell::Cell;
+ | ^^ use of undeclared crate or module `st`
+ |
+help: there is a crate or module with a similar name
+ |
+LL | use std::cell::Cell;
+ | ~~~
+
+error[E0432]: unresolved import `bas`
+ --> $DIR/crate-or-module-typo.rs:11:5
+ |
+LL | use bas::bar;
+ | ^^^ use of undeclared crate or module `bas`
+ |
+help: there is a crate or module with a similar name
+ |
+LL | use bar::bar;
+ | ~~~
+
+error[E0433]: failed to resolve: use of undeclared crate or module `bar`
+ --> $DIR/crate-or-module-typo.rs:6:20
+ |
+LL | pub fn bar() { bar::baz(); }
+ | ^^^ use of undeclared crate or module `bar`
+
+error[E0433]: failed to resolve: use of undeclared crate or module `st`
+ --> $DIR/crate-or-module-typo.rs:14:10
+ |
+LL | bar: st::cell::Cell<bool>
+ | ^^ use of undeclared crate or module `st`
+ |
+help: there is a crate or module with a similar name
+ |
+LL | bar: std::cell::Cell<bool>
+ | ~~~
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0432, E0433.
+For more information about an error, try `rustc --explain E0432`.