diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 67deb3d977942..fe5dedb6ba4b7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -320,7 +320,7 @@ jobs: - name: dist-aarch64-apple env: SCRIPT: "./x.py dist --stage 2" - RUST_CONFIGURE_ARGS: "--build=x86_64-apple-darwin --host=aarch64-apple-darwin --target=aarch64-apple-darwin --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc --set llvm.ninja=false" + RUST_CONFIGURE_ARGS: "--build=x86_64-apple-darwin --host=aarch64-apple-darwin --target=aarch64-apple-darwin --enable-full-tools --enable-sanitizers --enable-profiler --disable-docs --set rust.jemalloc --set llvm.ninja=false" RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 USE_XCODE_CLANG: 1 MACOSX_DEPLOYMENT_TARGET: 11.0 diff --git a/Cargo.lock b/Cargo.lock index 73ffd3e044eb3..a7496e61b8beb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -152,7 +152,9 @@ dependencies = [ "nom", "proc-macro2", "quote", + "serde", "syn", + "toml", ] [[package]] diff --git a/compiler/rustc_ast_pretty/src/pp.rs b/compiler/rustc_ast_pretty/src/pp.rs index 25437f8b53a94..bdd70148d85a0 100644 --- a/compiler/rustc_ast_pretty/src/pp.rs +++ b/compiler/rustc_ast_pretty/src/pp.rs @@ -167,14 +167,9 @@ pub enum Token { Break(BreakToken), Begin(BeginToken), End, - Eof, } impl Token { - crate fn is_eof(&self) -> bool { - matches!(self, Token::Eof) - } - pub fn is_hardbreak_tok(&self) -> bool { matches!(self, Token::Break(BreakToken { offset: 0, blank_space: SIZE_INFINITY })) } @@ -187,7 +182,6 @@ impl fmt::Display for Token { Token::Break(_) => f.write_str("BREAK"), Token::Begin(_) => f.write_str("BEGIN"), Token::End => f.write_str("END"), - Token::Eof => f.write_str("EOF"), } } } @@ -212,10 +206,6 @@ pub struct Printer { margin: isize, /// Number of spaces left on line space: isize, - /// Index of left side of input stream - left: usize, - /// Index of right side of input stream - right: usize, /// Ring-buffer of tokens and calculated sizes buf: RingBuffer, /// Running size of stream "...left" @@ -233,6 +223,9 @@ pub struct Printer { print_stack: Vec, /// Buffered indentation to avoid writing trailing whitespace pending_indentation: isize, + /// The token most recently popped from the left boundary of the + /// ring-buffer for printing + last_printed: Option, } #[derive(Clone)] @@ -241,39 +234,34 @@ struct BufEntry { size: isize, } -impl Default for BufEntry { - fn default() -> Self { - BufEntry { token: Token::Eof, size: 0 } - } -} - impl Printer { pub fn new() -> Self { let linewidth = 78; - let mut buf = RingBuffer::new(); - buf.advance_right(); Printer { out: String::new(), margin: linewidth as isize, space: linewidth as isize, - left: 0, - right: 0, - buf, + buf: RingBuffer::new(), left_total: 0, right_total: 0, scan_stack: VecDeque::new(), print_stack: Vec::new(), pending_indentation: 0, + last_printed: None, } } - pub fn last_token(&self) -> Token { - self.buf[self.right].token.clone() + pub fn last_token(&self) -> Option<&Token> { + self.last_token_still_buffered().or_else(|| self.last_printed.as_ref()) + } + + pub fn last_token_still_buffered(&self) -> Option<&Token> { + self.buf.last().map(|last| &last.token) } /// Be very careful with this! - pub fn replace_last_token(&mut self, t: Token) { - self.buf[self.right].token = t; + pub fn replace_last_token_still_buffered(&mut self, t: Token) { + self.buf.last_mut().unwrap().token = t; } fn scan_eof(&mut self) { @@ -287,20 +275,18 @@ impl Printer { if self.scan_stack.is_empty() { self.left_total = 1; self.right_total = 1; - self.right = self.left; - self.buf.truncate(1); - } else { - self.advance_right(); + self.buf.clear(); } - self.scan_push(BufEntry { token: Token::Begin(b), size: -self.right_total }); + let right = self.buf.push(BufEntry { token: Token::Begin(b), size: -self.right_total }); + self.scan_stack.push_front(right); } fn scan_end(&mut self) { if self.scan_stack.is_empty() { self.print_end(); } else { - self.advance_right(); - self.scan_push(BufEntry { token: Token::End, size: -1 }); + let right = self.buf.push(BufEntry { token: Token::End, size: -1 }); + self.scan_stack.push_front(right); } } @@ -308,68 +294,44 @@ impl Printer { if self.scan_stack.is_empty() { self.left_total = 1; self.right_total = 1; - self.right = self.left; - self.buf.truncate(1); + self.buf.clear(); } else { - self.advance_right(); + self.check_stack(0); } - self.check_stack(0); - self.scan_push(BufEntry { token: Token::Break(b), size: -self.right_total }); + let right = self.buf.push(BufEntry { token: Token::Break(b), size: -self.right_total }); + self.scan_stack.push_front(right); self.right_total += b.blank_space; } fn scan_string(&mut self, s: Cow<'static, str>) { if self.scan_stack.is_empty() { - self.print_string(s); + self.print_string(&s); } else { - self.advance_right(); let len = s.len() as isize; - self.buf[self.right] = BufEntry { token: Token::String(s), size: len }; + self.buf.push(BufEntry { token: Token::String(s), size: len }); self.right_total += len; self.check_stream(); } } fn check_stream(&mut self) { - if self.right_total - self.left_total > self.space { - if Some(&self.left) == self.scan_stack.back() { - let scanned = self.scan_pop_bottom(); - self.buf[scanned].size = SIZE_INFINITY; + while self.right_total - self.left_total > self.space { + if *self.scan_stack.back().unwrap() == self.buf.index_of_first() { + self.scan_stack.pop_back().unwrap(); + self.buf.first_mut().unwrap().size = SIZE_INFINITY; } self.advance_left(); - if self.left != self.right { - self.check_stream(); + if self.buf.is_empty() { + break; } } } - fn scan_push(&mut self, entry: BufEntry) { - self.buf[self.right] = entry; - self.scan_stack.push_front(self.right); - } - - fn scan_pop(&mut self) -> usize { - self.scan_stack.pop_front().unwrap() - } - - fn scan_top(&self) -> usize { - *self.scan_stack.front().unwrap() - } - - fn scan_pop_bottom(&mut self) -> usize { - self.scan_stack.pop_back().unwrap() - } - - fn advance_right(&mut self) { - self.right += 1; - self.buf.advance_right(); - } - fn advance_left(&mut self) { - let mut left_size = self.buf[self.left].size; + let mut left_size = self.buf.first().unwrap().size; while left_size >= 0 { - let left = self.buf[self.left].token.clone(); + let left = self.buf.first().unwrap().token.clone(); let len = match left { Token::Break(b) => b.blank_space, @@ -385,39 +347,38 @@ impl Printer { self.left_total += len; - if self.left == self.right { + self.buf.advance_left(); + if self.buf.is_empty() { break; } - self.buf.advance_left(); - self.left += 1; - - left_size = self.buf[self.left].size; + left_size = self.buf.first().unwrap().size; } } - fn check_stack(&mut self, k: usize) { - if !self.scan_stack.is_empty() { - let x = self.scan_top(); - match self.buf[x].token { + fn check_stack(&mut self, mut k: usize) { + while let Some(&x) = self.scan_stack.front() { + let mut entry = &mut self.buf[x]; + match entry.token { Token::Begin(_) => { - if k > 0 { - self.scan_pop(); - self.buf[x].size += self.right_total; - self.check_stack(k - 1); + if k == 0 { + break; } + self.scan_stack.pop_front().unwrap(); + entry.size += self.right_total; + k -= 1; } Token::End => { // paper says + not =, but that makes no sense. - self.scan_pop(); - self.buf[x].size = 1; - self.check_stack(k + 1); + self.scan_stack.pop_front().unwrap(); + entry.size = 1; + k += 1; } _ => { - self.scan_pop(); - self.buf[x].size += self.right_total; - if k > 0 { - self.check_stack(k); + self.scan_stack.pop_front().unwrap(); + entry.size += self.right_total; + if k == 0 { + break; } } } @@ -477,7 +438,7 @@ impl Printer { } } - fn print_string(&mut self, s: Cow<'static, str>) { + fn print_string(&mut self, s: &str) { let len = s.len() as isize; // assert!(len <= space); self.space -= len; @@ -491,21 +452,21 @@ impl Printer { self.out.reserve(self.pending_indentation as usize); self.out.extend(std::iter::repeat(' ').take(self.pending_indentation as usize)); self.pending_indentation = 0; - self.out.push_str(&s); + self.out.push_str(s); } fn print(&mut self, token: Token, l: isize) { - match token { - Token::Begin(b) => self.print_begin(b, l), + match &token { + Token::Begin(b) => self.print_begin(*b, l), Token::End => self.print_end(), - Token::Break(b) => self.print_break(b, l), + Token::Break(b) => self.print_break(*b, l), Token::String(s) => { let len = s.len() as isize; assert_eq!(len, l); self.print_string(s); } - Token::Eof => panic!(), // Eof should never get here. } + self.last_printed = Some(token); } // Convenience functions to talk to the printer. @@ -560,7 +521,10 @@ impl Printer { } pub fn is_beginning_of_line(&self) -> bool { - self.last_token().is_eof() || self.last_token().is_hardbreak_tok() + match self.last_token() { + Some(last_token) => last_token.is_hardbreak_tok(), + None => true, + } } pub fn hardbreak_tok_offset(off: isize) -> Token { diff --git a/compiler/rustc_ast_pretty/src/pp/ring.rs b/compiler/rustc_ast_pretty/src/pp/ring.rs index 7e4e353ef1f8c..d20142eb591fe 100644 --- a/compiler/rustc_ast_pretty/src/pp/ring.rs +++ b/compiler/rustc_ast_pretty/src/pp/ring.rs @@ -22,11 +22,14 @@ impl RingBuffer { RingBuffer { data: VecDeque::new(), offset: 0 } } - pub fn advance_right(&mut self) - where - T: Default, - { - self.data.push_back(T::default()); + pub fn is_empty(&self) -> bool { + self.data.is_empty() + } + + pub fn push(&mut self, value: T) -> usize { + let index = self.offset + self.data.len(); + self.data.push_back(value); + index } pub fn advance_left(&mut self) { @@ -34,8 +37,28 @@ impl RingBuffer { self.offset += 1; } - pub fn truncate(&mut self, len: usize) { - self.data.truncate(len); + pub fn clear(&mut self) { + self.data.clear(); + } + + pub fn index_of_first(&self) -> usize { + self.offset + } + + pub fn first(&self) -> Option<&T> { + self.data.front() + } + + pub fn first_mut(&mut self) -> Option<&mut T> { + self.data.front_mut() + } + + pub fn last(&self) -> Option<&T> { + self.data.back() + } + + pub fn last_mut(&mut self) -> Option<&mut T> { + self.data.back_mut() } } diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs index 487451466f1f0..1cbc3162d4326 100644 --- a/compiler/rustc_ast_pretty/src/pprust/state.rs +++ b/compiler/rustc_ast_pretty/src/pprust/state.rs @@ -328,9 +328,9 @@ pub trait PrintState<'a>: std::ops::Deref + std::ops::Dere CommentStyle::BlankLine => { // We need to do at least one, possibly two hardbreaks. let twice = match self.last_token() { - pp::Token::String(s) => ";" == s, - pp::Token::Begin(_) => true, - pp::Token::End => true, + Some(pp::Token::String(s)) => ";" == s, + Some(pp::Token::Begin(_)) => true, + Some(pp::Token::End) => true, _ => false, }; if twice { @@ -686,11 +686,15 @@ pub trait PrintState<'a>: std::ops::Deref + std::ops::Dere fn break_offset_if_not_bol(&mut self, n: usize, off: isize) { if !self.is_beginning_of_line() { self.break_offset(n, off) - } else if off != 0 && self.last_token().is_hardbreak_tok() { - // We do something pretty sketchy here: tuck the nonzero - // offset-adjustment we were going to deposit along with the - // break into the previous hardbreak. - self.replace_last_token(pp::Printer::hardbreak_tok_offset(off)); + } else if off != 0 { + if let Some(last_token) = self.last_token_still_buffered() { + if last_token.is_hardbreak_tok() { + // We do something pretty sketchy here: tuck the nonzero + // offset-adjustment we were going to deposit along with the + // break into the previous hardbreak. + self.replace_last_token_still_buffered(pp::Printer::hardbreak_tok_offset(off)); + } + } } } diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs index f4703b22ecbcf..55c9b4d9ba12d 100644 --- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs +++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs @@ -90,7 +90,7 @@ macro call_intrinsic_match { match $intrinsic { $( sym::$name => { - assert!($substs.is_noop()); + assert!($substs.is_empty()); if let [$(ref $arg),*] = *$args { let ($($arg,)*) = ( $(codegen_operand($fx, $arg),)* diff --git a/compiler/rustc_middle/src/ty/subst.rs b/compiler/rustc_middle/src/ty/subst.rs index ab33fbcca15a3..63e9b58584c5f 100644 --- a/compiler/rustc_middle/src/ty/subst.rs +++ b/compiler/rustc_middle/src/ty/subst.rs @@ -275,10 +275,6 @@ impl<'a, 'tcx> InternalSubsts<'tcx> { } } - pub fn is_noop(&self) -> bool { - self.is_empty() - } - #[inline] pub fn types(&'a self) -> impl DoubleEndedIterator> + 'a { self.iter() diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs index 809b973252974..0d51f7779e18f 100644 --- a/compiler/rustc_symbol_mangling/src/v0.rs +++ b/compiler/rustc_symbol_mangling/src/v0.rs @@ -772,9 +772,9 @@ impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx> { disambiguated_data: &DisambiguatedDefPathData, ) -> Result { let ns = match disambiguated_data.data { - // FIXME: It shouldn't be necessary to add anything for extern block segments, - // but we add 't' for backward compatibility. - DefPathData::ForeignMod => 't', + // Extern block segments can be skipped, names from extern blocks + // are effectively living in their parent modules. + DefPathData::ForeignMod => return print_prefix(self), // Uppercase categories are more stable than lowercase ones. DefPathData::TypeNs(_) => 't', diff --git a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs index cd2e0f18e0cc0..195a4a4a653e1 100644 --- a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs @@ -484,7 +484,7 @@ crate fn to_pretty_impl_header(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Option FnCtxt<'a, 'tcx> { // `foo.bar::(...)` -- the `Self` type here will be the // type of `foo` (possibly adjusted), but we don't want to // include that. We want just the `[_, u32]` part. - if !method.substs.is_noop() { + if !method.substs.is_empty() { let method_generics = self.tcx.generics_of(method.def_id); if !method_generics.params.is_empty() { let user_type_annotation = self.infcx.probe(|_| { @@ -211,7 +211,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } pub fn write_substs(&self, node_id: hir::HirId, substs: SubstsRef<'tcx>) { - if !substs.is_noop() { + if !substs.is_empty() { debug!("write_substs({:?}, {:?}) in fcx {}", node_id, substs, self.tag()); self.typeck_results.borrow_mut().node_substs_mut().insert(node_id, substs); diff --git a/library/core/src/future/pending.rs b/library/core/src/future/pending.rs index 560dd25ecff42..2877e66eca885 100644 --- a/library/core/src/future/pending.rs +++ b/library/core/src/future/pending.rs @@ -12,7 +12,7 @@ use crate::task::{Context, Poll}; #[stable(feature = "future_readiness_fns", since = "1.48.0")] #[must_use = "futures do nothing unless you `.await` or poll them"] pub struct Pending { - _data: marker::PhantomData, + _data: marker::PhantomData T>, } /// Creates a future which never resolves, representing a computation that never @@ -43,9 +43,6 @@ impl Future for Pending { } } -#[stable(feature = "future_readiness_fns", since = "1.48.0")] -impl Unpin for Pending {} - #[stable(feature = "future_readiness_fns", since = "1.48.0")] impl Debug for Pending { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { diff --git a/library/core/src/hash/mod.rs b/library/core/src/hash/mod.rs index 3ff84cc9672eb..53de8b42c059f 100644 --- a/library/core/src/hash/mod.rs +++ b/library/core/src/hash/mod.rs @@ -602,7 +602,7 @@ pub trait BuildHasher { /// [`HashSet`]: ../../std/collections/struct.HashSet.html /// [zero-sized]: https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts #[stable(since = "1.7.0", feature = "build_hasher")] -pub struct BuildHasherDefault(marker::PhantomData); +pub struct BuildHasherDefault(marker::PhantomData H>); #[stable(since = "1.9.0", feature = "core_impl_debug")] impl fmt::Debug for BuildHasherDefault { diff --git a/library/core/src/iter/sources/empty.rs b/library/core/src/iter/sources/empty.rs index 7abe01d17c90b..98734c527f2b9 100644 --- a/library/core/src/iter/sources/empty.rs +++ b/library/core/src/iter/sources/empty.rs @@ -22,17 +22,17 @@ pub const fn empty() -> Empty { Empty(marker::PhantomData) } +// Newtype for use in `PhantomData` to avoid +// > error: const-stable function cannot use `#[feature(const_fn_fn_ptr_basics)]` +// in `const fn empty()` above. +struct FnReturning(fn() -> T); + /// An iterator that yields nothing. /// /// This `struct` is created by the [`empty()`] function. See its documentation for more. #[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "iter_empty", since = "1.2.0")] -pub struct Empty(marker::PhantomData); - -#[stable(feature = "iter_empty_send_sync", since = "1.42.0")] -unsafe impl Send for Empty {} -#[stable(feature = "iter_empty_send_sync", since = "1.42.0")] -unsafe impl Sync for Empty {} +pub struct Empty(marker::PhantomData>); #[stable(feature = "core_impl_debug", since = "1.9.0")] impl fmt::Debug for Empty { diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs index 7d9b3da48ecb0..a46a4e63714c2 100644 --- a/src/bootstrap/dist.rs +++ b/src/bootstrap/dist.rs @@ -1483,11 +1483,10 @@ impl Step for Extended { }; prepare("rustc"); prepare("cargo"); - prepare("rust-docs"); prepare("rust-std"); prepare("rust-analysis"); prepare("clippy"); - for tool in &["rust-demangler", "rls", "rust-analyzer", "miri"] { + for tool in &["rust-docs", "rust-demangler", "rls", "rust-analyzer", "miri"] { if built_tools.contains(tool) { prepare(tool); } diff --git a/src/ci/github-actions/ci.yml b/src/ci/github-actions/ci.yml index ac5d5822bfbd5..a70cdc4b519e6 100644 --- a/src/ci/github-actions/ci.yml +++ b/src/ci/github-actions/ci.yml @@ -496,6 +496,7 @@ jobs: --enable-full-tools --enable-sanitizers --enable-profiler + --disable-docs --set rust.jemalloc --set llvm.ninja=false RUSTC_RETRY_LINKER_ON_SEGFAULT: 1 diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml index ccb844cd10b25..67d167e86df7f 100644 --- a/src/librustdoc/Cargo.toml +++ b/src/librustdoc/Cargo.toml @@ -8,7 +8,7 @@ path = "lib.rs" [dependencies] arrayvec = { version = "0.7", default-features = false } -askama = { version = "0.11", default-features = false } +askama = { version = "0.11", default-features = false, features = ["config"] } atty = "0.2" pulldown-cmark = { version = "0.9", default-features = false } minifier = "0.0.41" diff --git a/src/librustdoc/askama.toml b/src/librustdoc/askama.toml new file mode 100644 index 0000000000000..0c984f637ba29 --- /dev/null +++ b/src/librustdoc/askama.toml @@ -0,0 +1,2 @@ +[general] +dirs = ["html/templates"] diff --git a/src/librustdoc/templates/STYLE.md b/src/librustdoc/html/templates/STYLE.md similarity index 100% rename from src/librustdoc/templates/STYLE.md rename to src/librustdoc/html/templates/STYLE.md diff --git a/src/librustdoc/templates/page.html b/src/librustdoc/html/templates/page.html similarity index 100% rename from src/librustdoc/templates/page.html rename to src/librustdoc/html/templates/page.html diff --git a/src/librustdoc/templates/print_item.html b/src/librustdoc/html/templates/print_item.html similarity index 100% rename from src/librustdoc/templates/print_item.html rename to src/librustdoc/html/templates/print_item.html diff --git a/src/test/ui/symbol-names/foreign-types.rs b/src/test/ui/symbol-names/foreign-types.rs new file mode 100644 index 0000000000000..8f5b07769caff --- /dev/null +++ b/src/test/ui/symbol-names/foreign-types.rs @@ -0,0 +1,19 @@ +// build-fail +// compile-flags: -C symbol-mangling-version=v0 + +#![feature(extern_types)] +#![feature(rustc_attrs)] + +extern "C" { + type ForeignType; +} + +struct Check(T); + +#[rustc_symbol_name] +//~^ ERROR symbol-name(_RMCs +//~| ERROR demangling(>) +impl Check {} + +fn main() {} diff --git a/src/test/ui/symbol-names/foreign-types.stderr b/src/test/ui/symbol-names/foreign-types.stderr new file mode 100644 index 0000000000000..fcffdd2a8ec15 --- /dev/null +++ b/src/test/ui/symbol-names/foreign-types.stderr @@ -0,0 +1,20 @@ +error: symbol-name(_RMCsCRATE_HASH_13foreign_typesINtB_5CheckNvB_11ForeignTypeE) + --> $DIR/foreign-types.rs:13:1 + | +LL | #[rustc_symbol_name] + | ^^^^^^^^^^^^^^^^^^^^ + +error: demangling(>) + --> $DIR/foreign-types.rs:13:1 + | +LL | #[rustc_symbol_name] + | ^^^^^^^^^^^^^^^^^^^^ + +error: demangling-alt(>) + --> $DIR/foreign-types.rs:13:1 + | +LL | #[rustc_symbol_name] + | ^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 3 previous errors + diff --git a/src/tools/build-manifest/README.md b/src/tools/build-manifest/README.md index b77c5a907c118..44c96f31d0ba8 100644 --- a/src/tools/build-manifest/README.md +++ b/src/tools/build-manifest/README.md @@ -20,8 +20,7 @@ Then, you can generate the manifest and all the packages from `path/to/dist` to `path/to/output` with: ``` -$ cargo +nightly run path/to/dist path/to/output 1970-01-01 http://example.com \ - CHANNEL VERSION +$ cargo +nightly run path/to/dist path/to/output 1970-01-01 http://example.com CHANNEL ``` Remember to replace `CHANNEL` with the channel you produced dist artifacts of diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index c1579ae9ac54a..6b56d6bc4adf0 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -155,17 +155,19 @@ static TARGETS: &[&str] = &[ "x86_64-unknown-hermit", ]; -static DOCS_TARGETS: &[&str] = &[ - "aarch64-unknown-linux-gnu", - "i686-apple-darwin", - "i686-pc-windows-gnu", - "i686-pc-windows-msvc", - "i686-unknown-linux-gnu", - "x86_64-apple-darwin", - "x86_64-pc-windows-gnu", - "x86_64-pc-windows-msvc", - "x86_64-unknown-linux-gnu", - "x86_64-unknown-linux-musl", +/// This allows the manifest to contain rust-docs for hosts that don't build +/// docs. +/// +/// Tuples of `(host_partial, host_instead)`. If the host does not have the +/// rust-docs component available, then if the host name contains +/// `host_partial`, it will use the docs from `host_instead` instead. +/// +/// The order here matters, more specific entries should be first. +static DOCS_FALLBACK: &[(&str, &str)] = &[ + ("-apple-", "x86_64-apple-darwin"), + ("aarch64", "aarch64-unknown-linux-gnu"), + ("arm-", "aarch64-unknown-linux-gnu"), + ("", "x86_64-unknown-linux-gnu"), ]; static MSI_INSTALLERS: &[&str] = &[ @@ -301,23 +303,27 @@ impl Builder { } fn add_packages_to(&mut self, manifest: &mut Manifest) { - let mut package = |name, targets| self.package(name, &mut manifest.pkg, targets); - package("rustc", HOSTS); - package("rustc-dev", HOSTS); - package("reproducible-artifacts", HOSTS); - package("rustc-docs", HOSTS); - package("cargo", HOSTS); - package("rust-mingw", MINGW); - package("rust-std", TARGETS); - package("rust-docs", DOCS_TARGETS); - package("rust-src", &["*"]); - package("rls-preview", HOSTS); - package("rust-analyzer-preview", HOSTS); - package("clippy-preview", HOSTS); - package("miri-preview", HOSTS); - package("rustfmt-preview", HOSTS); - package("rust-analysis", TARGETS); - package("llvm-tools-preview", TARGETS); + macro_rules! package { + ($name:expr, $targets:expr) => { + self.package($name, &mut manifest.pkg, $targets, &[]) + }; + } + package!("rustc", HOSTS); + package!("rustc-dev", HOSTS); + package!("reproducible-artifacts", HOSTS); + package!("rustc-docs", HOSTS); + package!("cargo", HOSTS); + package!("rust-mingw", MINGW); + package!("rust-std", TARGETS); + self.package("rust-docs", &mut manifest.pkg, HOSTS, DOCS_FALLBACK); + package!("rust-src", &["*"]); + package!("rls-preview", HOSTS); + package!("rust-analyzer-preview", HOSTS); + package!("clippy-preview", HOSTS); + package!("miri-preview", HOSTS); + package!("rustfmt-preview", HOSTS); + package!("rust-analysis", TARGETS); + package!("llvm-tools-preview", TARGETS); } fn add_artifacts_to(&mut self, manifest: &mut Manifest) { @@ -500,7 +506,13 @@ impl Builder { .extend(pkgs.iter().map(|s| (*s).to_owned())); } - fn package(&mut self, pkgname: &str, dst: &mut BTreeMap, targets: &[&str]) { + fn package( + &mut self, + pkgname: &str, + dst: &mut BTreeMap, + targets: &[&str], + fallback: &[(&str, &str)], + ) { let version_info = self .versions .version(&PkgType::from_component(pkgname)) @@ -512,16 +524,32 @@ impl Builder { is_present = false; // Pretend the component is entirely missing. } + macro_rules! tarball_name { + ($target_name:expr) => { + self.versions.tarball_name(&PkgType::from_component(pkgname), $target_name).unwrap() + }; + } + let mut target_from_compressed_tar = |target_name| { + let target = Target::from_compressed_tar(self, &tarball_name!(target_name)); + if target.available { + return target; + } + for (substr, fallback_target) in fallback { + if target_name.contains(substr) { + let t = Target::from_compressed_tar(self, &tarball_name!(fallback_target)); + // Fallbacks must always be available. + assert!(t.available); + return t; + } + } + Target::unavailable() + }; + let targets = targets .iter() .map(|name| { let target = if is_present { - let filename = self - .versions - .tarball_name(&PkgType::from_component(pkgname), name) - .unwrap(); - - Target::from_compressed_tar(self, &filename) + target_from_compressed_tar(name) } else { // If the component is not present for this build add it anyway but mark it as // unavailable -- this way rustup won't allow upgrades without --force diff --git a/src/tools/build-manifest/src/versions.rs b/src/tools/build-manifest/src/versions.rs index 11575139adcf6..95c2297de264b 100644 --- a/src/tools/build-manifest/src/versions.rs +++ b/src/tools/build-manifest/src/versions.rs @@ -169,7 +169,7 @@ impl Versions { } pub(crate) fn archive_name( - &mut self, + &self, package: &PkgType, target: &str, extension: &str, @@ -189,11 +189,7 @@ impl Versions { } } - pub(crate) fn tarball_name( - &mut self, - package: &PkgType, - target: &str, - ) -> Result { + pub(crate) fn tarball_name(&self, package: &PkgType, target: &str) -> Result { self.archive_name(package, target, "tar.gz") } diff --git a/src/tools/rust-demangler/tests/lib.rs b/src/tools/rust-demangler/tests/lib.rs index 5a67b42322535..85019df7867dd 100644 --- a/src/tools/rust-demangler/tests/lib.rs +++ b/src/tools/rust-demangler/tests/lib.rs @@ -29,14 +29,14 @@ cc[4d6468d6c9fd4bb3]::spawn::{closure#0}::{closure#0} as core[846817f741e54dfd]::iter::iterator::Iterator>::rposition::::{closure#0} alloc[f15a878b47eb696b]::alloc::box_free::> INtC8arrayvec8ArrayVechKj7b_E -> -> -> -> -> -> -> -> +> +> +> +> +> +> +> +> >::foo::FOO foo[0] foo[0] @@ -51,14 +51,14 @@ cc::spawn::{closure#0}::{closure#0} as core::iter::iterator::Iterator>::rposition::::{closure#0} alloc::alloc::box_free::> INtC8arrayvec8ArrayVechKj7b_E -> -> -> -> -> -> -> -> +> +> +> +> +> +> +> +> >::foo::FOO foo[0] foo[0]