mirror of https://github.com/rust-lang/rust.git
Auto merge of #125989 - GuillaumeGomez:rollup-xu69i13, r=GuillaumeGomez
Rollup of 11 pull requests Successful merges: - #106186 (Add function `core::iter::chain`) - #125596 (Convert `proc_macro_back_compat` lint to an unconditional error.) - #125696 (Explain differences between `{Once,Lazy}{Cell,Lock}` types) - #125917 (Create `run-make` `env_var` and `env_var_os` helpers) - #125927 (Ignore `vec_deque_alloc_error::test_shrink_to_unwind` test on non-unwind targets) - #125930 (feat(opt-dist): new flag `--benchmark-cargo-config`) - #125932 (Fix typo in the docs of `HashMap::raw_entry_mut`) - #125933 (Update books) - #125944 (Update fuchsia maintainers) - #125946 (Include trailing commas in wrapped function declarations [RustDoc]) - #125973 (Remove `tests/run-make-fulldeps/pretty-expanded`) Failed merges: - #125815 (`rustc_parse` top-level cleanups) r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
a330e49593
|
|
@ -124,6 +124,9 @@ expand_not_a_meta_item =
|
|||
expand_only_one_word =
|
||||
must only be one word
|
||||
|
||||
expand_proc_macro_back_compat = using an old version of `{$crate_name}`
|
||||
.note = older versions of the `{$crate_name}` crate no longer compile; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives
|
||||
|
||||
expand_proc_macro_derive_panicked =
|
||||
proc-macro derive panicked
|
||||
.help = message: {$message}
|
||||
|
|
|
|||
|
|
@ -14,8 +14,7 @@ use rustc_data_structures::fx::FxIndexMap;
|
|||
use rustc_data_structures::sync::{self, Lrc};
|
||||
use rustc_errors::{DiagCtxt, ErrorGuaranteed, PResult};
|
||||
use rustc_feature::Features;
|
||||
use rustc_lint_defs::builtin::PROC_MACRO_BACK_COMPAT;
|
||||
use rustc_lint_defs::{BufferedEarlyLint, BuiltinLintDiag, RegisteredTools};
|
||||
use rustc_lint_defs::{BufferedEarlyLint, RegisteredTools};
|
||||
use rustc_parse::{parser, MACRO_ARGUMENTS};
|
||||
use rustc_session::config::CollapseMacroDebuginfo;
|
||||
use rustc_session::{parse::ParseSess, Limit, Session};
|
||||
|
|
@ -1330,80 +1329,63 @@ pub fn parse_macro_name_and_helper_attrs(
|
|||
Some((trait_ident.name, proc_attrs))
|
||||
}
|
||||
|
||||
/// This nonterminal looks like some specific enums from
|
||||
/// `proc-macro-hack` and `procedural-masquerade` crates.
|
||||
/// We need to maintain some special pretty-printing behavior for them due to incorrect
|
||||
/// asserts in old versions of those crates and their wide use in the ecosystem.
|
||||
/// See issue #73345 for more details.
|
||||
/// If this item looks like a specific enums from `rental`, emit a fatal error.
|
||||
/// See #73345 and #83125 for more details.
|
||||
/// FIXME(#73933): Remove this eventually.
|
||||
fn pretty_printing_compatibility_hack(item: &Item, sess: &Session) -> bool {
|
||||
fn pretty_printing_compatibility_hack(item: &Item, sess: &Session) {
|
||||
let name = item.ident.name;
|
||||
if name == sym::ProceduralMasqueradeDummyType {
|
||||
if let ast::ItemKind::Enum(enum_def, _) = &item.kind {
|
||||
if let [variant] = &*enum_def.variants {
|
||||
if variant.ident.name == sym::Input {
|
||||
let filename = sess.source_map().span_to_filename(item.ident.span);
|
||||
if let FileName::Real(real) = filename {
|
||||
if let Some(c) = real
|
||||
.local_path()
|
||||
.unwrap_or(Path::new(""))
|
||||
.components()
|
||||
.flat_map(|c| c.as_os_str().to_str())
|
||||
.find(|c| c.starts_with("rental") || c.starts_with("allsorts-rental"))
|
||||
{
|
||||
let crate_matches = if c.starts_with("allsorts-rental") {
|
||||
true
|
||||
} else {
|
||||
let mut version = c.trim_start_matches("rental-").split('.');
|
||||
version.next() == Some("0")
|
||||
&& version.next() == Some("5")
|
||||
&& version
|
||||
.next()
|
||||
.and_then(|c| c.parse::<u32>().ok())
|
||||
.is_some_and(|v| v < 6)
|
||||
};
|
||||
if name == sym::ProceduralMasqueradeDummyType
|
||||
&& let ast::ItemKind::Enum(enum_def, _) = &item.kind
|
||||
&& let [variant] = &*enum_def.variants
|
||||
&& variant.ident.name == sym::Input
|
||||
&& let FileName::Real(real) = sess.source_map().span_to_filename(item.ident.span)
|
||||
&& let Some(c) = real
|
||||
.local_path()
|
||||
.unwrap_or(Path::new(""))
|
||||
.components()
|
||||
.flat_map(|c| c.as_os_str().to_str())
|
||||
.find(|c| c.starts_with("rental") || c.starts_with("allsorts-rental"))
|
||||
{
|
||||
let crate_matches = if c.starts_with("allsorts-rental") {
|
||||
true
|
||||
} else {
|
||||
let mut version = c.trim_start_matches("rental-").split('.');
|
||||
version.next() == Some("0")
|
||||
&& version.next() == Some("5")
|
||||
&& version.next().and_then(|c| c.parse::<u32>().ok()).is_some_and(|v| v < 6)
|
||||
};
|
||||
|
||||
if crate_matches {
|
||||
sess.psess.buffer_lint(
|
||||
PROC_MACRO_BACK_COMPAT,
|
||||
item.ident.span,
|
||||
ast::CRATE_NODE_ID,
|
||||
BuiltinLintDiag::ProcMacroBackCompat {
|
||||
crate_name: "rental".to_string(),
|
||||
fixed_version: "0.5.6".to_string(),
|
||||
},
|
||||
);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if crate_matches {
|
||||
// FIXME: make this translatable
|
||||
#[allow(rustc::untranslatable_diagnostic)]
|
||||
sess.psess.dcx.emit_fatal(errors::ProcMacroBackCompat {
|
||||
crate_name: "rental".to_string(),
|
||||
fixed_version: "0.5.6".to_string(),
|
||||
});
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub(crate) fn ann_pretty_printing_compatibility_hack(ann: &Annotatable, sess: &Session) -> bool {
|
||||
pub(crate) fn ann_pretty_printing_compatibility_hack(ann: &Annotatable, sess: &Session) {
|
||||
let item = match ann {
|
||||
Annotatable::Item(item) => item,
|
||||
Annotatable::Stmt(stmt) => match &stmt.kind {
|
||||
ast::StmtKind::Item(item) => item,
|
||||
_ => return false,
|
||||
_ => return,
|
||||
},
|
||||
_ => return false,
|
||||
_ => return,
|
||||
};
|
||||
pretty_printing_compatibility_hack(item, sess)
|
||||
}
|
||||
|
||||
pub(crate) fn nt_pretty_printing_compatibility_hack(nt: &Nonterminal, sess: &Session) -> bool {
|
||||
pub(crate) fn nt_pretty_printing_compatibility_hack(nt: &Nonterminal, sess: &Session) {
|
||||
let item = match nt {
|
||||
Nonterminal::NtItem(item) => item,
|
||||
Nonterminal::NtStmt(stmt) => match &stmt.kind {
|
||||
ast::StmtKind::Item(item) => item,
|
||||
_ => return false,
|
||||
_ => return,
|
||||
},
|
||||
_ => return false,
|
||||
_ => return,
|
||||
};
|
||||
pretty_printing_compatibility_hack(item, sess)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -440,3 +440,13 @@ pub(crate) struct EmptyDelegationList {
|
|||
#[primary_span]
|
||||
pub span: Span,
|
||||
}
|
||||
|
||||
// This used to be the `proc_macro_back_compat` lint (#83125). It was later
|
||||
// turned into a hard error.
|
||||
#[derive(Diagnostic)]
|
||||
#[diag(expand_proc_macro_back_compat)]
|
||||
#[note]
|
||||
pub struct ProcMacroBackCompat {
|
||||
pub crate_name: String,
|
||||
pub fixed_version: String,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -267,7 +267,6 @@ pub(super) fn transcribe<'a>(
|
|||
// some of the unnecessary whitespace.
|
||||
let ident = MacroRulesNormalizedIdent::new(original_ident);
|
||||
if let Some(cur_matched) = lookup_cur_matched(ident, interp, &repeats) {
|
||||
// njn: explain the use of alone here
|
||||
let tt = match cur_matched {
|
||||
MatchedSingle(ParseNtResult::Tt(tt)) => {
|
||||
// `tt`s are emitted into the output stream directly as "raw tokens",
|
||||
|
|
|
|||
|
|
@ -4,14 +4,12 @@ use crate::proc_macro_server;
|
|||
|
||||
use rustc_ast as ast;
|
||||
use rustc_ast::ptr::P;
|
||||
use rustc_ast::token;
|
||||
use rustc_ast::tokenstream::TokenStream;
|
||||
use rustc_data_structures::sync::Lrc;
|
||||
use rustc_errors::ErrorGuaranteed;
|
||||
use rustc_parse::parser::ForceCollect;
|
||||
use rustc_session::config::ProcMacroExecutionStrategy;
|
||||
use rustc_span::profiling::SpannedEventArgRecorder;
|
||||
use rustc_span::{Span, DUMMY_SP};
|
||||
use rustc_span::Span;
|
||||
|
||||
struct MessagePipe<T> {
|
||||
tx: std::sync::mpsc::SyncSender<T>,
|
||||
|
|
@ -120,18 +118,13 @@ impl MultiItemModifier for DeriveProcMacro {
|
|||
// We need special handling for statement items
|
||||
// (e.g. `fn foo() { #[derive(Debug)] struct Bar; }`)
|
||||
let is_stmt = matches!(item, Annotatable::Stmt(..));
|
||||
let hack = crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess);
|
||||
let input = if hack {
|
||||
let nt = match item {
|
||||
Annotatable::Item(item) => token::NtItem(item),
|
||||
Annotatable::Stmt(stmt) => token::NtStmt(stmt),
|
||||
_ => unreachable!(),
|
||||
};
|
||||
TokenStream::token_alone(token::Interpolated(Lrc::new(nt)), DUMMY_SP)
|
||||
} else {
|
||||
item.to_tokens()
|
||||
};
|
||||
|
||||
// We used to have an alternative behaviour for crates that needed it.
|
||||
// We had a lint for a long time, but now we just emit a hard error.
|
||||
// Eventually we might remove the special case hard error check
|
||||
// altogether. See #73345.
|
||||
crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess);
|
||||
let input = item.to_tokens();
|
||||
let stream = {
|
||||
let _timer =
|
||||
ecx.sess.prof.generic_activity_with_arg_recorder("expand_proc_macro", |recorder| {
|
||||
|
|
|
|||
|
|
@ -276,21 +276,20 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
|
|||
|
||||
Interpolated(nt) => {
|
||||
let stream = TokenStream::from_nonterminal_ast(&nt);
|
||||
// A hack used to pass AST fragments to attribute and derive
|
||||
// macros as a single nonterminal token instead of a token
|
||||
// stream. Such token needs to be "unwrapped" and not
|
||||
// represented as a delimited group.
|
||||
// FIXME: It needs to be removed, but there are some
|
||||
// compatibility issues (see #73345).
|
||||
if crate::base::nt_pretty_printing_compatibility_hack(&nt, rustc.ecx.sess) {
|
||||
trees.extend(Self::from_internal((stream, rustc)));
|
||||
} else {
|
||||
trees.push(TokenTree::Group(Group {
|
||||
delimiter: pm::Delimiter::None,
|
||||
stream: Some(stream),
|
||||
span: DelimSpan::from_single(span),
|
||||
}))
|
||||
}
|
||||
// We used to have an alternative behaviour for crates that
|
||||
// needed it: a hack used to pass AST fragments to
|
||||
// attribute and derive macros as a single nonterminal
|
||||
// token instead of a token stream. Such token needs to be
|
||||
// "unwrapped" and not represented as a delimited group. We
|
||||
// had a lint for a long time, but now we just emit a hard
|
||||
// error. Eventually we might remove the special case hard
|
||||
// error check altogether. See #73345.
|
||||
crate::base::nt_pretty_printing_compatibility_hack(&nt, rustc.ecx.sess);
|
||||
trees.push(TokenTree::Group(Group {
|
||||
delimiter: pm::Delimiter::None,
|
||||
stream: Some(stream),
|
||||
span: DelimSpan::from_single(span),
|
||||
}))
|
||||
}
|
||||
|
||||
OpenDelim(..) | CloseDelim(..) => unreachable!(),
|
||||
|
|
|
|||
|
|
@ -635,9 +635,6 @@ lint_pattern_in_foreign = patterns aren't allowed in foreign function declaratio
|
|||
lint_private_extern_crate_reexport =
|
||||
extern crate `{$ident}` is private, and cannot be re-exported, consider declaring with `pub`
|
||||
|
||||
lint_proc_macro_back_compat = using an old version of `{$crate_name}`
|
||||
.note = older versions of the `{$crate_name}` crate will stop compiling in future versions of Rust; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives
|
||||
|
||||
lint_proc_macro_derive_resolution_fallback = cannot find {$ns} `{$ident}` in this scope
|
||||
.label = names from parent modules are not accessible without an explicit import
|
||||
|
||||
|
|
|
|||
|
|
@ -159,9 +159,6 @@ pub(super) fn decorate_lint(sess: &Session, diagnostic: BuiltinLintDiag, diag: &
|
|||
BuiltinLintDiag::LegacyDeriveHelpers(label_span) => {
|
||||
lints::LegacyDeriveHelpers { span: label_span }.decorate_lint(diag);
|
||||
}
|
||||
BuiltinLintDiag::ProcMacroBackCompat { crate_name, fixed_version } => {
|
||||
lints::ProcMacroBackCompat { crate_name, fixed_version }.decorate_lint(diag);
|
||||
}
|
||||
BuiltinLintDiag::OrPatternsBackCompat(suggestion_span, suggestion) => {
|
||||
lints::OrPatternsBackCompat { span: suggestion_span, suggestion }.decorate_lint(diag);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2649,14 +2649,6 @@ pub struct LegacyDeriveHelpers {
|
|||
pub span: Span,
|
||||
}
|
||||
|
||||
#[derive(LintDiagnostic)]
|
||||
#[diag(lint_proc_macro_back_compat)]
|
||||
#[note]
|
||||
pub struct ProcMacroBackCompat {
|
||||
pub crate_name: String,
|
||||
pub fixed_version: String,
|
||||
}
|
||||
|
||||
#[derive(LintDiagnostic)]
|
||||
#[diag(lint_or_patterns_back_compat)]
|
||||
pub struct OrPatternsBackCompat {
|
||||
|
|
|
|||
|
|
@ -76,7 +76,6 @@ declare_lint_pass! {
|
|||
PATTERNS_IN_FNS_WITHOUT_BODY,
|
||||
PRIVATE_BOUNDS,
|
||||
PRIVATE_INTERFACES,
|
||||
PROC_MACRO_BACK_COMPAT,
|
||||
PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
|
||||
PUB_USE_OF_PRIVATE_EXTERN_CRATE,
|
||||
REDUNDANT_LIFETIMES,
|
||||
|
|
@ -3664,53 +3663,6 @@ declare_lint! {
|
|||
"detects invalid `#[doc(...)]` attributes",
|
||||
}
|
||||
|
||||
declare_lint! {
|
||||
/// The `proc_macro_back_compat` lint detects uses of old versions of certain
|
||||
/// proc-macro crates, which have hardcoded workarounds in the compiler.
|
||||
///
|
||||
/// ### Example
|
||||
///
|
||||
/// ```rust,ignore (needs-dependency)
|
||||
///
|
||||
/// use time_macros_impl::impl_macros;
|
||||
/// struct Foo;
|
||||
/// impl_macros!(Foo);
|
||||
/// ```
|
||||
///
|
||||
/// This will produce:
|
||||
///
|
||||
/// ```text
|
||||
/// warning: using an old version of `time-macros-impl`
|
||||
/// ::: $DIR/group-compat-hack.rs:27:5
|
||||
/// |
|
||||
/// LL | impl_macros!(Foo);
|
||||
/// | ------------------ in this macro invocation
|
||||
/// |
|
||||
/// = note: `#[warn(proc_macro_back_compat)]` on by default
|
||||
/// = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
/// = note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
/// = note: the `time-macros-impl` crate will stop compiling in futures version of Rust. Please update to the latest version of the `time` crate to avoid breakage
|
||||
/// = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
/// ```
|
||||
///
|
||||
/// ### Explanation
|
||||
///
|
||||
/// Eventually, the backwards-compatibility hacks present in the compiler will be removed,
|
||||
/// causing older versions of certain crates to stop compiling.
|
||||
/// This is a [future-incompatible] lint to ease the transition to an error.
|
||||
/// See [issue #83125] for more details.
|
||||
///
|
||||
/// [issue #83125]: https://github.com/rust-lang/rust/issues/83125
|
||||
/// [future-incompatible]: ../index.md#future-incompatible-lints
|
||||
pub PROC_MACRO_BACK_COMPAT,
|
||||
Deny,
|
||||
"detects usage of old versions of certain proc-macro crates",
|
||||
@future_incompatible = FutureIncompatibleInfo {
|
||||
reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
|
||||
reference: "issue #83125 <https://github.com/rust-lang/rust/issues/83125>",
|
||||
};
|
||||
}
|
||||
|
||||
declare_lint! {
|
||||
/// The `rust_2021_incompatible_or_patterns` lint detects usage of old versions of or-patterns.
|
||||
///
|
||||
|
|
|
|||
|
|
@ -618,10 +618,6 @@ pub enum BuiltinLintDiag {
|
|||
is_foreign: bool,
|
||||
},
|
||||
LegacyDeriveHelpers(Span),
|
||||
ProcMacroBackCompat {
|
||||
crate_name: String,
|
||||
fixed_version: String,
|
||||
},
|
||||
OrPatternsBackCompat(Span, String),
|
||||
ReservedPrefix(Span, String),
|
||||
TrailingMacro(bool, Ident),
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ use std::{
|
|||
};
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(not(panic = "unwind"), ignore = "test requires unwinding support")]
|
||||
fn test_shrink_to_unwind() {
|
||||
// This tests that `shrink_to` leaves the deque in a consistent state when
|
||||
// the call to `RawVec::shrink_to_fit` unwinds. The code is adapted from #123369
|
||||
|
|
|
|||
|
|
@ -82,6 +82,20 @@
|
|||
//!
|
||||
//! The corresponding [`Sync`] version of `OnceCell<T>` is [`OnceLock<T>`].
|
||||
//!
|
||||
//! ## `LazyCell<T, F>`
|
||||
//!
|
||||
//! A common pattern with OnceCell is, for a given OnceCell, to use the same function on every
|
||||
//! call to [`OnceCell::get_or_init`] with that cell. This is what is offered by [`LazyCell`],
|
||||
//! which pairs cells of `T` with functions of `F`, and always calls `F` before it yields `&T`.
|
||||
//! This happens implicitly by simply attempting to dereference the LazyCell to get its contents,
|
||||
//! so its use is much more transparent with a place which has been initialized by a constant.
|
||||
//!
|
||||
//! More complicated patterns that don't fit this description can be built on `OnceCell<T>` instead.
|
||||
//!
|
||||
//! `LazyCell` works by providing an implementation of `impl Deref` that calls the function,
|
||||
//! so you can just use it by dereference (e.g. `*lazy_cell` or `lazy_cell.deref()`).
|
||||
//!
|
||||
//! The corresponding [`Sync`] version of `LazyCell<T, F>` is [`LazyLock<T, F>`].
|
||||
//!
|
||||
//! # When to choose interior mutability
|
||||
//!
|
||||
|
|
@ -230,6 +244,7 @@
|
|||
//! [`RwLock<T>`]: ../../std/sync/struct.RwLock.html
|
||||
//! [`Mutex<T>`]: ../../std/sync/struct.Mutex.html
|
||||
//! [`OnceLock<T>`]: ../../std/sync/struct.OnceLock.html
|
||||
//! [`LazyLock<T, F>`]: ../../std/sync/struct.LazyLock.html
|
||||
//! [`Sync`]: ../../std/marker/trait.Sync.html
|
||||
//! [`atomic`]: crate::sync::atomic
|
||||
|
||||
|
|
|
|||
|
|
@ -4,8 +4,8 @@ use crate::ops::Try;
|
|||
|
||||
/// An iterator that links two iterators together, in a chain.
|
||||
///
|
||||
/// This `struct` is created by [`Iterator::chain`]. See its documentation
|
||||
/// for more.
|
||||
/// This `struct` is created by [`chain`] or [`Iterator::chain`]. See their
|
||||
/// documentation for more.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
|
|
@ -38,6 +38,39 @@ impl<A, B> Chain<A, B> {
|
|||
}
|
||||
}
|
||||
|
||||
/// Converts the arguments to iterators and links them together, in a chain.
|
||||
///
|
||||
/// See the documentation of [`Iterator::chain`] for more.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(iter_chain)]
|
||||
///
|
||||
/// use std::iter::chain;
|
||||
///
|
||||
/// let a = [1, 2, 3];
|
||||
/// let b = [4, 5, 6];
|
||||
///
|
||||
/// let mut iter = chain(a, b);
|
||||
///
|
||||
/// assert_eq!(iter.next(), Some(1));
|
||||
/// assert_eq!(iter.next(), Some(2));
|
||||
/// assert_eq!(iter.next(), Some(3));
|
||||
/// assert_eq!(iter.next(), Some(4));
|
||||
/// assert_eq!(iter.next(), Some(5));
|
||||
/// assert_eq!(iter.next(), Some(6));
|
||||
/// assert_eq!(iter.next(), None);
|
||||
/// ```
|
||||
#[unstable(feature = "iter_chain", reason = "recently added", issue = "125964")]
|
||||
pub fn chain<A, B>(a: A, b: B) -> Chain<A::IntoIter, B::IntoIter>
|
||||
where
|
||||
A: IntoIterator,
|
||||
B: IntoIterator<Item = A::Item>,
|
||||
{
|
||||
Chain::new(a.into_iter(), b.into_iter())
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<A, B> Iterator for Chain<A, B>
|
||||
where
|
||||
|
|
|
|||
|
|
@ -41,6 +41,9 @@ pub use self::array_chunks::ArrayChunks;
|
|||
#[unstable(feature = "std_internals", issue = "none")]
|
||||
pub use self::by_ref_sized::ByRefSized;
|
||||
|
||||
#[unstable(feature = "iter_chain", reason = "recently added", issue = "125964")]
|
||||
pub use self::chain::chain;
|
||||
|
||||
#[stable(feature = "iter_cloned", since = "1.1.0")]
|
||||
pub use self::cloned::Cloned;
|
||||
|
||||
|
|
|
|||
|
|
@ -428,6 +428,8 @@ pub use self::traits::{
|
|||
DoubleEndedIterator, ExactSizeIterator, Extend, FromIterator, IntoIterator, Product, Sum,
|
||||
};
|
||||
|
||||
#[unstable(feature = "iter_chain", reason = "recently added", issue = "125964")]
|
||||
pub use self::adapters::chain;
|
||||
#[stable(feature = "iter_zip", since = "1.59.0")]
|
||||
pub use self::adapters::zip;
|
||||
#[unstable(feature = "iter_array_chunks", reason = "recently added", issue = "100450")]
|
||||
|
|
|
|||
|
|
@ -2,6 +2,14 @@ use super::*;
|
|||
use core::iter::*;
|
||||
use core::num::NonZero;
|
||||
|
||||
#[test]
|
||||
fn test_chain() {
|
||||
let xs = [0, 1, 2, 3, 4, 5];
|
||||
let ys = [30, 40, 50, 60];
|
||||
let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60];
|
||||
assert_eq!(Vec::from_iter(chain(xs, ys)), expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iterator_chain() {
|
||||
let xs = [0, 1, 2, 3, 4, 5];
|
||||
|
|
|
|||
|
|
@ -75,6 +75,7 @@
|
|||
#![feature(ip)]
|
||||
#![feature(iter_advance_by)]
|
||||
#![feature(iter_array_chunks)]
|
||||
#![feature(iter_chain)]
|
||||
#![feature(iter_collect_into)]
|
||||
#![feature(iter_partition_in_place)]
|
||||
#![feature(iter_intersperse)]
|
||||
|
|
|
|||
|
|
@ -1218,7 +1218,7 @@ where
|
|||
/// will cause the map to produce seemingly random results. Higher-level and
|
||||
/// more foolproof APIs like `entry` should be preferred when possible.
|
||||
///
|
||||
/// In particular, the hash used to initialized the raw entry must still be
|
||||
/// In particular, the hash used to initialize the raw entry must still be
|
||||
/// consistent with the hash of the key that is ultimately stored in the entry.
|
||||
/// This is because implementations of HashMap may need to recompute hashes
|
||||
/// when resizing, at which point only the keys are available.
|
||||
|
|
|
|||
|
|
@ -29,34 +29,26 @@ union Data<T, F> {
|
|||
/// # Examples
|
||||
///
|
||||
/// Initialize static variables with `LazyLock`.
|
||||
///
|
||||
/// ```
|
||||
/// use std::collections::HashMap;
|
||||
///
|
||||
/// use std::sync::LazyLock;
|
||||
///
|
||||
/// static HASHMAP: LazyLock<HashMap<i32, String>> = LazyLock::new(|| {
|
||||
/// println!("initializing");
|
||||
/// let mut m = HashMap::new();
|
||||
/// m.insert(13, "Spica".to_string());
|
||||
/// m.insert(74, "Hoyten".to_string());
|
||||
/// m
|
||||
/// // n.b. static items do not call [`Drop`] on program termination, so this won't be deallocated.
|
||||
/// // this is fine, as the OS can deallocate the terminated program faster than we can free memory
|
||||
/// // but tools like valgrind might report "memory leaks" as it isn't obvious this is intentional.
|
||||
/// static DEEP_THOUGHT: LazyLock<String> = LazyLock::new(|| {
|
||||
/// # mod another_crate {
|
||||
/// # pub fn great_question() -> String { "42".to_string() }
|
||||
/// # }
|
||||
/// // M3 Ultra takes about 16 million years in --release config
|
||||
/// another_crate::great_question()
|
||||
/// });
|
||||
///
|
||||
/// fn main() {
|
||||
/// println!("ready");
|
||||
/// std::thread::spawn(|| {
|
||||
/// println!("{:?}", HASHMAP.get(&13));
|
||||
/// }).join().unwrap();
|
||||
/// println!("{:?}", HASHMAP.get(&74));
|
||||
///
|
||||
/// // Prints:
|
||||
/// // ready
|
||||
/// // initializing
|
||||
/// // Some("Spica")
|
||||
/// // Some("Hoyten")
|
||||
/// }
|
||||
/// // The `String` is built, stored in the `LazyLock`, and returned as `&String`.
|
||||
/// let _ = &*DEEP_THOUGHT;
|
||||
/// // The `String` is retrieved from the `LazyLock` and returned as `&String`.
|
||||
/// let _ = &*DEEP_THOUGHT;
|
||||
/// ```
|
||||
///
|
||||
/// Initialize fields with `LazyLock`.
|
||||
/// ```
|
||||
/// use std::sync::LazyLock;
|
||||
|
|
|
|||
|
|
@ -136,7 +136,10 @@
|
|||
//! - [`Once`]: Used for a thread-safe, one-time global initialization routine
|
||||
//!
|
||||
//! - [`OnceLock`]: Used for thread-safe, one-time initialization of a
|
||||
//! global variable.
|
||||
//! variable, with potentially different initializers based on the caller.
|
||||
//!
|
||||
//! - [`LazyLock`]: Used for thread-safe, one-time initialization of a
|
||||
//! variable, using one nullary initializer function provided at creation.
|
||||
//!
|
||||
//! - [`RwLock`]: Provides a mutual exclusion mechanism which allows
|
||||
//! multiple readers at the same time, while allowing only one
|
||||
|
|
|
|||
|
|
@ -8,47 +8,17 @@ use crate::sync::Once;
|
|||
/// A synchronization primitive which can nominally be written to only once.
|
||||
///
|
||||
/// This type is a thread-safe [`OnceCell`], and can be used in statics.
|
||||
/// In many simple cases, you can use [`LazyLock<T, F>`] instead to get the benefits of this type
|
||||
/// with less effort: `LazyLock<T, F>` "looks like" `&T` because it initializes with `F` on deref!
|
||||
/// Where OnceLock shines is when LazyLock is too simple to support a given case, as LazyLock
|
||||
/// doesn't allow additional inputs to its function after you call [`LazyLock::new(|| ...)`].
|
||||
///
|
||||
/// [`OnceCell`]: crate::cell::OnceCell
|
||||
/// [`LazyLock<T, F>`]: crate::sync::LazyLock
|
||||
/// [`LazyLock::new(|| ...)`]: crate::sync::LazyLock::new
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Using `OnceLock` to store a function’s previously computed value (a.k.a.
|
||||
/// ‘lazy static’ or ‘memoizing’):
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::OnceLock;
|
||||
///
|
||||
/// struct DeepThought {
|
||||
/// answer: String,
|
||||
/// }
|
||||
///
|
||||
/// impl DeepThought {
|
||||
/// # fn great_question() -> String {
|
||||
/// # "42".to_string()
|
||||
/// # }
|
||||
/// #
|
||||
/// fn new() -> Self {
|
||||
/// Self {
|
||||
/// // M3 Ultra takes about 16 million years in --release config
|
||||
/// answer: Self::great_question(),
|
||||
/// }
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// fn computation() -> &'static DeepThought {
|
||||
/// // n.b. static items do not call [`Drop`] on program termination, so if
|
||||
/// // [`DeepThought`] impls Drop, that will not be used for this instance.
|
||||
/// static COMPUTATION: OnceLock<DeepThought> = OnceLock::new();
|
||||
/// COMPUTATION.get_or_init(|| DeepThought::new())
|
||||
/// }
|
||||
///
|
||||
/// // The `DeepThought` is built, stored in the `OnceLock`, and returned.
|
||||
/// let _ = computation().answer;
|
||||
/// // The `DeepThought` is retrieved from the `OnceLock` and returned.
|
||||
/// let _ = computation().answer;
|
||||
/// ```
|
||||
///
|
||||
/// Writing to a `OnceLock` from a separate thread:
|
||||
///
|
||||
/// ```
|
||||
|
|
@ -73,6 +43,55 @@ use crate::sync::Once;
|
|||
/// Some(&12345),
|
||||
/// );
|
||||
/// ```
|
||||
///
|
||||
/// You can use `OnceLock` to implement a type that requires "append-only" logic:
|
||||
///
|
||||
/// ```
|
||||
/// use std::sync::{OnceLock, atomic::{AtomicU32, Ordering}};
|
||||
/// use std::thread;
|
||||
///
|
||||
/// struct OnceList<T> {
|
||||
/// data: OnceLock<T>,
|
||||
/// next: OnceLock<Box<OnceList<T>>>,
|
||||
/// }
|
||||
/// impl<T> OnceList<T> {
|
||||
/// const fn new() -> OnceList<T> {
|
||||
/// OnceList { data: OnceLock::new(), next: OnceLock::new() }
|
||||
/// }
|
||||
/// fn push(&self, value: T) {
|
||||
/// // FIXME: this impl is concise, but is also slow for long lists or many threads.
|
||||
/// // as an exercise, consider how you might improve on it while preserving the behavior
|
||||
/// if let Err(value) = self.data.set(value) {
|
||||
/// let next = self.next.get_or_init(|| Box::new(OnceList::new()));
|
||||
/// next.push(value)
|
||||
/// };
|
||||
/// }
|
||||
/// fn contains(&self, example: &T) -> bool
|
||||
/// where
|
||||
/// T: PartialEq,
|
||||
/// {
|
||||
/// self.data.get().map(|item| item == example).filter(|v| *v).unwrap_or_else(|| {
|
||||
/// self.next.get().map(|next| next.contains(example)).unwrap_or(false)
|
||||
/// })
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// // Let's exercise this new Sync append-only list by doing a little counting
|
||||
/// static LIST: OnceList<u32> = OnceList::new();
|
||||
/// static COUNTER: AtomicU32 = AtomicU32::new(0);
|
||||
///
|
||||
/// let vec = (0..thread::available_parallelism().unwrap().get()).map(|_| thread::spawn(|| {
|
||||
/// while let i @ 0..=1000 = COUNTER.fetch_add(1, Ordering::Relaxed) {
|
||||
/// LIST.push(i);
|
||||
/// }
|
||||
/// })).collect::<Vec<thread::JoinHandle<_>>>();
|
||||
/// vec.into_iter().for_each(|handle| handle.join().unwrap());
|
||||
///
|
||||
/// for i in 0..=1000 {
|
||||
/// assert!(LIST.contains(&i));
|
||||
/// }
|
||||
///
|
||||
/// ```
|
||||
#[stable(feature = "once_cell", since = "1.70.0")]
|
||||
pub struct OnceLock<T> {
|
||||
once: Once,
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 85442a608426d3667f1c9458ad457b241a36b569
|
||||
Subproject commit 5228bfac8267ad24659a81b92ec5417976b5edbc
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit 0c68e90acaae5a611f8f5098a3c2980de9845ab2
|
||||
Subproject commit bbaabbe088e21a81a0d9ae6757705020d5d7b416
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit dd962bb82865a5284f2404e5234f1e3222b9c022
|
||||
Subproject commit b10c6acaf0f43481f6600e95d4b5013446e29f7a
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit e356977fceaa8591c762312d8d446769166d4b3e
|
||||
Subproject commit 6019b76f5b28938565b251bbba0bf5cc5c43d863
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit 20482893d1a502df72f76762c97aed88854cdf81
|
||||
Subproject commit 4840dca06cadf48b305d3ce0aeafde7f80933f80
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit b6d4a4940bab85cc91eec70cc2e3096dd48da62d
|
||||
Subproject commit 6a7374bd87cbac0f8be4fd4877d8186d9c313985
|
||||
|
|
@ -10,9 +10,9 @@ updatable, and performant.
|
|||
The [Fuchsia team]:
|
||||
|
||||
- Tyler Mandry ([@tmandry](https://github.com/tmandry))
|
||||
- Dan Johnson ([@computerdruid](https://github.com/computerdruid))
|
||||
- David Koloski ([@djkoloski](https://github.com/djkoloski))
|
||||
- Joseph Ryan ([@P1n3appl3](https://github.com/P1n3appl3))
|
||||
- Julia Ryan ([@P1n3appl3](https://github.com/P1n3appl3))
|
||||
- Erick Tryzelaar ([@erickt](https://github.com/erickt))
|
||||
|
||||
As the team evolves over time, the specific members listed here may differ from
|
||||
the members reported by the API. The API should be considered to be
|
||||
|
|
|
|||
|
|
@ -1438,13 +1438,9 @@ impl clean::FnDecl {
|
|||
{
|
||||
write!(f, "\n{}", Indent(n + 4))?;
|
||||
}
|
||||
|
||||
let last_input_index = self.inputs.values.len().checked_sub(1);
|
||||
for (i, input) in self.inputs.values.iter().enumerate() {
|
||||
if i > 0 {
|
||||
match line_wrapping_indent {
|
||||
None => write!(f, ", ")?,
|
||||
Some(n) => write!(f, ",\n{}", Indent(n + 4))?,
|
||||
};
|
||||
}
|
||||
if let Some(selfty) = input.to_self() {
|
||||
match selfty {
|
||||
clean::SelfValue => {
|
||||
|
|
@ -1477,18 +1473,25 @@ impl clean::FnDecl {
|
|||
write!(f, "{}: ", input.name)?;
|
||||
input.type_.print(cx).fmt(f)?;
|
||||
}
|
||||
match (line_wrapping_indent, last_input_index) {
|
||||
(_, None) => (),
|
||||
(None, Some(last_i)) if i != last_i => write!(f, ", ")?,
|
||||
(None, Some(_)) => (),
|
||||
(Some(n), Some(last_i)) if i != last_i => write!(f, ",\n{}", Indent(n + 4))?,
|
||||
(Some(_), Some(_)) => write!(f, ",\n")?,
|
||||
}
|
||||
}
|
||||
|
||||
if self.c_variadic {
|
||||
match line_wrapping_indent {
|
||||
None => write!(f, ", ...")?,
|
||||
Some(n) => write!(f, "\n{}...", Indent(n + 4))?,
|
||||
Some(n) => write!(f, "{}...\n", Indent(n + 4))?,
|
||||
};
|
||||
}
|
||||
|
||||
match line_wrapping_indent {
|
||||
None => write!(f, ")")?,
|
||||
Some(n) => write!(f, "\n{})", Indent(n))?,
|
||||
Some(n) => write!(f, "{})", Indent(n))?,
|
||||
};
|
||||
|
||||
self.print_output(cx).fmt(f)
|
||||
|
|
|
|||
|
|
@ -17,6 +17,9 @@ pub struct Environment {
|
|||
host_llvm_dir: Utf8PathBuf,
|
||||
/// List of test paths that should be skipped when testing the optimized artifacts.
|
||||
skipped_tests: Vec<String>,
|
||||
/// Arguments passed to `rustc-perf --cargo-config <value>` when running benchmarks.
|
||||
#[builder(default)]
|
||||
benchmark_cargo_config: Vec<String>,
|
||||
/// Directory containing a pre-built rustc-perf checkout.
|
||||
#[builder(default)]
|
||||
prebuilt_rustc_perf: Option<Utf8PathBuf>,
|
||||
|
|
@ -94,6 +97,10 @@ impl Environment {
|
|||
pub fn skipped_tests(&self) -> &[String] {
|
||||
&self.skipped_tests
|
||||
}
|
||||
|
||||
pub fn benchmark_cargo_config(&self) -> &[String] {
|
||||
&self.benchmark_cargo_config
|
||||
}
|
||||
}
|
||||
|
||||
/// What is the extension of binary executables on this platform?
|
||||
|
|
|
|||
|
|
@ -90,6 +90,10 @@ enum EnvironmentCmd {
|
|||
|
||||
#[clap(flatten)]
|
||||
shared: SharedArgs,
|
||||
|
||||
/// Arguments passed to `rustc-perf --cargo-config <value>` when running benchmarks.
|
||||
#[arg(long)]
|
||||
benchmark_cargo_config: Vec<String>,
|
||||
},
|
||||
/// Perform an optimized build on Linux CI, from inside Docker.
|
||||
LinuxCi {
|
||||
|
|
@ -119,6 +123,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
|
|||
llvm_shared,
|
||||
use_bolt,
|
||||
skipped_tests,
|
||||
benchmark_cargo_config,
|
||||
shared,
|
||||
} => {
|
||||
let env = EnvironmentBuilder::default()
|
||||
|
|
@ -132,6 +137,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
|
|||
.shared_llvm(llvm_shared)
|
||||
.use_bolt(use_bolt)
|
||||
.skipped_tests(skipped_tests)
|
||||
.benchmark_cargo_config(benchmark_cargo_config)
|
||||
.build()?;
|
||||
|
||||
(env, shared.build_args)
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ fn init_compiler_benchmarks(
|
|||
// Run rustc-perf benchmarks
|
||||
// Benchmark using profile_local with eprintln, which essentially just means
|
||||
// don't actually benchmark -- just make sure we run rustc a bunch of times.
|
||||
cmd(&[
|
||||
let mut cmd = cmd(&[
|
||||
env.cargo_stage_0().as_str(),
|
||||
"run",
|
||||
"-p",
|
||||
|
|
@ -61,7 +61,17 @@ fn init_compiler_benchmarks(
|
|||
.env("RUST_LOG", "collector=debug")
|
||||
.env("RUSTC", env.rustc_stage_0().as_str())
|
||||
.env("RUSTC_BOOTSTRAP", "1")
|
||||
.workdir(&env.rustc_perf_dir())
|
||||
.workdir(&env.rustc_perf_dir());
|
||||
|
||||
// This propagates cargo configs to `rustc-perf --cargo-config`,
|
||||
// which is particularly useful when the environment is air-gapped,
|
||||
// and you want to use the default set of training crates vendored
|
||||
// in the rustc-src tarball.
|
||||
for config in env.benchmark_cargo_config() {
|
||||
cmd = cmd.arg("--cargo-config").arg(config);
|
||||
}
|
||||
|
||||
cmd
|
||||
}
|
||||
|
||||
/// Describes which `llvm-profdata` binary should be used for merging PGO profiles.
|
||||
|
|
|
|||
|
|
@ -1,8 +1,9 @@
|
|||
use std::env;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
use crate::{bin_name, cygpath_windows, handle_failed_output, is_msvc, is_windows, tmp_dir, uname};
|
||||
use crate::{
|
||||
bin_name, cygpath_windows, env_var, handle_failed_output, is_msvc, is_windows, tmp_dir, uname,
|
||||
};
|
||||
|
||||
/// Construct a new platform-specific C compiler invocation.
|
||||
///
|
||||
|
|
@ -27,11 +28,11 @@ impl Cc {
|
|||
/// WARNING: This means that what flags are accepted by the underlying C compile is
|
||||
/// platform- AND compiler-specific. Consult the relevant docs for `gcc`, `clang` and `mvsc`.
|
||||
pub fn new() -> Self {
|
||||
let compiler = env::var("CC").unwrap();
|
||||
let compiler = env_var("CC");
|
||||
|
||||
let mut cmd = Command::new(compiler);
|
||||
|
||||
let default_cflags = env::var("CC_DEFAULT_FLAGS").unwrap();
|
||||
let default_cflags = env_var("CC_DEFAULT_FLAGS");
|
||||
for flag in default_cflags.split(char::is_whitespace) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
use std::env;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
use crate::{bin_name, handle_failed_output, tmp_dir};
|
||||
use crate::{bin_name, env_var, handle_failed_output, tmp_dir};
|
||||
|
||||
/// Construct a new `clang` invocation. `clang` is not always available for all targets.
|
||||
pub fn clang() -> Clang {
|
||||
|
|
@ -20,8 +19,7 @@ crate::impl_common_helpers!(Clang);
|
|||
impl Clang {
|
||||
/// Construct a new `clang` invocation. `clang` is not always available for all targets.
|
||||
pub fn new() -> Self {
|
||||
let clang =
|
||||
env::var("CLANG").expect("`CLANG` not specified, but this is required to find `clang`");
|
||||
let clang = env_var("CLANG");
|
||||
let cmd = Command::new(clang);
|
||||
Self { cmd }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ pub mod rustc;
|
|||
pub mod rustdoc;
|
||||
|
||||
use std::env;
|
||||
use std::ffi::OsString;
|
||||
use std::fs;
|
||||
use std::io;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
|
@ -30,14 +31,28 @@ pub use run::{run, run_fail};
|
|||
pub use rustc::{aux_build, rustc, Rustc};
|
||||
pub use rustdoc::{bare_rustdoc, rustdoc, Rustdoc};
|
||||
|
||||
pub fn env_var(name: &str) -> String {
|
||||
match env::var(name) {
|
||||
Ok(v) => v,
|
||||
Err(err) => panic!("failed to retrieve environment variable {name:?}: {err:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn env_var_os(name: &str) -> OsString {
|
||||
match env::var_os(name) {
|
||||
Some(v) => v,
|
||||
None => panic!("failed to retrieve environment variable {name:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Path of `TMPDIR` (a temporary build directory, not under `/tmp`).
|
||||
pub fn tmp_dir() -> PathBuf {
|
||||
env::var_os("TMPDIR").unwrap().into()
|
||||
env_var_os("TMPDIR").into()
|
||||
}
|
||||
|
||||
/// `TARGET`
|
||||
pub fn target() -> String {
|
||||
env::var("TARGET").unwrap()
|
||||
env_var("TARGET")
|
||||
}
|
||||
|
||||
/// Check if target is windows-like.
|
||||
|
|
@ -62,7 +77,7 @@ pub fn static_lib(name: &str) -> PathBuf {
|
|||
}
|
||||
|
||||
pub fn python_command() -> Command {
|
||||
let python_path = std::env::var("PYTHON").expect("PYTHON environment variable does not exist");
|
||||
let python_path = env_var("PYTHON");
|
||||
Command::new(python_path)
|
||||
}
|
||||
|
||||
|
|
@ -73,7 +88,7 @@ pub fn htmldocck() -> Command {
|
|||
}
|
||||
|
||||
pub fn source_path() -> PathBuf {
|
||||
std::env::var("S").expect("S variable does not exist").into()
|
||||
env_var("S").into()
|
||||
}
|
||||
|
||||
/// Construct the static library name based on the platform.
|
||||
|
|
@ -208,12 +223,12 @@ fn handle_failed_output(cmd: &Command, output: Output, caller_line_number: u32)
|
|||
|
||||
/// Set the runtime library path as needed for running the host rustc/rustdoc/etc.
|
||||
pub fn set_host_rpath(cmd: &mut Command) {
|
||||
let ld_lib_path_envvar = env::var("LD_LIB_PATH_ENVVAR").unwrap();
|
||||
let ld_lib_path_envvar = env_var("LD_LIB_PATH_ENVVAR");
|
||||
cmd.env(&ld_lib_path_envvar, {
|
||||
let mut paths = vec![];
|
||||
paths.push(PathBuf::from(env::var("TMPDIR").unwrap()));
|
||||
paths.push(PathBuf::from(env::var("HOST_RPATH_DIR").unwrap()));
|
||||
for p in env::split_paths(&env::var(&ld_lib_path_envvar).unwrap()) {
|
||||
paths.push(PathBuf::from(env_var("TMPDIR")));
|
||||
paths.push(PathBuf::from(env_var("HOST_RPATH_DIR")));
|
||||
for p in env::split_paths(&env_var(&ld_lib_path_envvar)) {
|
||||
paths.push(p.to_path_buf());
|
||||
}
|
||||
env::join_paths(paths.iter()).unwrap()
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
use std::env;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
use crate::handle_failed_output;
|
||||
use crate::{env_var, handle_failed_output};
|
||||
|
||||
/// Construct a new `llvm-readobj` invocation. This assumes that `llvm-readobj` is available
|
||||
/// at `$LLVM_BIN_DIR/llvm-readobj`.
|
||||
|
|
@ -22,8 +21,7 @@ impl LlvmReadobj {
|
|||
/// Construct a new `llvm-readobj` invocation. This assumes that `llvm-readobj` is available
|
||||
/// at `$LLVM_BIN_DIR/llvm-readobj`.
|
||||
pub fn new() -> Self {
|
||||
let llvm_bin_dir = env::var("LLVM_BIN_DIR")
|
||||
.expect("`LLVM_BIN_DIR` not specified, but this is required to find `llvm-readobj`");
|
||||
let llvm_bin_dir = env_var("LLVM_BIN_DIR");
|
||||
let llvm_bin_dir = PathBuf::from(llvm_bin_dir);
|
||||
let llvm_readobj = llvm_bin_dir.join("llvm-readobj");
|
||||
let cmd = Command::new(llvm_readobj);
|
||||
|
|
|
|||
|
|
@ -2,23 +2,23 @@ use std::env;
|
|||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Output};
|
||||
|
||||
use crate::is_windows;
|
||||
use crate::{env_var, is_windows};
|
||||
|
||||
use super::handle_failed_output;
|
||||
|
||||
fn run_common(name: &str) -> (Command, Output) {
|
||||
let mut bin_path = PathBuf::new();
|
||||
bin_path.push(env::var("TMPDIR").unwrap());
|
||||
bin_path.push(env_var("TMPDIR"));
|
||||
bin_path.push(name);
|
||||
let ld_lib_path_envvar = env::var("LD_LIB_PATH_ENVVAR").unwrap();
|
||||
let ld_lib_path_envvar = env_var("LD_LIB_PATH_ENVVAR");
|
||||
let mut cmd = Command::new(bin_path);
|
||||
cmd.env(&ld_lib_path_envvar, {
|
||||
let mut paths = vec![];
|
||||
paths.push(PathBuf::from(env::var("TMPDIR").unwrap()));
|
||||
for p in env::split_paths(&env::var("TARGET_RPATH_ENV").unwrap()) {
|
||||
paths.push(PathBuf::from(env_var("TMPDIR")));
|
||||
for p in env::split_paths(&env_var("TARGET_RPATH_ENV")) {
|
||||
paths.push(p.to_path_buf());
|
||||
}
|
||||
for p in env::split_paths(&env::var(&ld_lib_path_envvar).unwrap()) {
|
||||
for p in env::split_paths(&env_var(&ld_lib_path_envvar)) {
|
||||
paths.push(p.to_path_buf());
|
||||
}
|
||||
env::join_paths(paths.iter()).unwrap()
|
||||
|
|
@ -29,7 +29,7 @@ fn run_common(name: &str) -> (Command, Output) {
|
|||
for p in env::split_paths(&std::env::var("PATH").unwrap_or(String::new())) {
|
||||
paths.push(p.to_path_buf());
|
||||
}
|
||||
paths.push(Path::new(&std::env::var("TARGET_RPATH_DIR").unwrap()).to_path_buf());
|
||||
paths.push(Path::new(&env_var("TARGET_RPATH_DIR")).to_path_buf());
|
||||
cmd.env("PATH", env::join_paths(paths.iter()).unwrap());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,10 +1,9 @@
|
|||
use std::env;
|
||||
use std::ffi::{OsStr, OsString};
|
||||
use std::io::Write;
|
||||
use std::path::Path;
|
||||
use std::process::{Command, Output, Stdio};
|
||||
|
||||
use crate::{handle_failed_output, set_host_rpath, tmp_dir};
|
||||
use crate::{env_var, handle_failed_output, set_host_rpath, tmp_dir};
|
||||
|
||||
/// Construct a new `rustc` invocation.
|
||||
pub fn rustc() -> Rustc {
|
||||
|
|
@ -26,7 +25,7 @@ pub struct Rustc {
|
|||
crate::impl_common_helpers!(Rustc);
|
||||
|
||||
fn setup_common() -> Command {
|
||||
let rustc = env::var("RUSTC").unwrap();
|
||||
let rustc = env_var("RUSTC");
|
||||
let mut cmd = Command::new(rustc);
|
||||
set_host_rpath(&mut cmd);
|
||||
cmd.arg("--out-dir").arg(tmp_dir()).arg("-L").arg(tmp_dir());
|
||||
|
|
|
|||
|
|
@ -1,10 +1,9 @@
|
|||
use std::env;
|
||||
use std::ffi::OsStr;
|
||||
use std::io::Write;
|
||||
use std::path::Path;
|
||||
use std::process::{Command, Output, Stdio};
|
||||
|
||||
use crate::{handle_failed_output, set_host_rpath};
|
||||
use crate::{env_var, env_var_os, handle_failed_output, set_host_rpath};
|
||||
|
||||
/// Construct a plain `rustdoc` invocation with no flags set.
|
||||
pub fn bare_rustdoc() -> Rustdoc {
|
||||
|
|
@ -25,7 +24,7 @@ pub struct Rustdoc {
|
|||
crate::impl_common_helpers!(Rustdoc);
|
||||
|
||||
fn setup_common() -> Command {
|
||||
let rustdoc = env::var("RUSTDOC").unwrap();
|
||||
let rustdoc = env_var("RUSTDOC");
|
||||
let mut cmd = Command::new(rustdoc);
|
||||
set_host_rpath(&mut cmd);
|
||||
cmd
|
||||
|
|
@ -41,7 +40,7 @@ impl Rustdoc {
|
|||
/// Construct a `rustdoc` invocation with `-L $(TARGET_RPATH_DIR)` set.
|
||||
pub fn new() -> Self {
|
||||
let mut cmd = setup_common();
|
||||
let target_rpath_dir = env::var_os("TARGET_RPATH_DIR").unwrap();
|
||||
let target_rpath_dir = env_var_os("TARGET_RPATH_DIR");
|
||||
cmd.arg(format!("-L{}", target_rpath_dir.to_string_lossy()));
|
||||
Self { cmd, stdin: None }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit cc81f9654dac3fe08de286907dba747538417afd
|
||||
Subproject commit 72daa50ce2350f5a9b5ae6dc3ad6babccd14ec0a
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
include ../../run-make/tools.mk
|
||||
|
||||
all:
|
||||
$(RUSTC) -o $(TMPDIR)/input.expanded.rs -Zunpretty=expanded input.rs
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
// #13544
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct A;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct B(isize);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct C {
|
||||
x: isize,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum D {}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum E {
|
||||
y,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum F {
|
||||
z(isize),
|
||||
}
|
||||
|
|
@ -14,7 +14,6 @@
|
|||
|
||||
#![deny(warnings)]
|
||||
|
||||
use run_make_support::object;
|
||||
use run_make_support::object::read::archive::ArchiveFile;
|
||||
use run_make_support::object::read::Object;
|
||||
use run_make_support::object::ObjectSection;
|
||||
|
|
@ -22,6 +21,7 @@ use run_make_support::object::ObjectSymbol;
|
|||
use run_make_support::object::RelocationTarget;
|
||||
use run_make_support::set_host_rpath;
|
||||
use run_make_support::tmp_dir;
|
||||
use run_make_support::{env_var, object};
|
||||
use std::collections::HashSet;
|
||||
|
||||
const MANIFEST: &str = r#"
|
||||
|
|
@ -35,7 +35,7 @@ path = "lib.rs""#;
|
|||
|
||||
fn main() {
|
||||
let target_dir = tmp_dir().join("target");
|
||||
let target = std::env::var("TARGET").unwrap();
|
||||
let target = env_var("TARGET");
|
||||
|
||||
println!("Testing compiler_builtins for {}", target);
|
||||
|
||||
|
|
@ -44,9 +44,9 @@ fn main() {
|
|||
std::fs::write(&manifest_path, MANIFEST.as_bytes()).unwrap();
|
||||
std::fs::write(tmp_dir().join("lib.rs"), b"#![no_std]").unwrap();
|
||||
|
||||
let path = std::env::var("PATH").unwrap();
|
||||
let rustc = std::env::var("RUSTC").unwrap();
|
||||
let bootstrap_cargo = std::env::var("BOOTSTRAP_CARGO").unwrap();
|
||||
let path = env_var("PATH");
|
||||
let rustc = env_var("RUSTC");
|
||||
let bootstrap_cargo = env_var("BOOTSTRAP_CARGO");
|
||||
let mut cmd = std::process::Command::new(bootstrap_cargo);
|
||||
cmd.args([
|
||||
"build",
|
||||
|
|
|
|||
|
|
@ -2,15 +2,14 @@
|
|||
//! a "hello world" application by setting `PATH` to `C:\Windows\System32`.
|
||||
//@ only-windows
|
||||
|
||||
use run_make_support::{rustc, tmp_dir};
|
||||
use std::env;
|
||||
use run_make_support::{env_var, rustc, tmp_dir};
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
|
||||
fn main() {
|
||||
rustc().input("hello.rs").run();
|
||||
|
||||
let windows_dir = env::var("SystemRoot").unwrap();
|
||||
let windows_dir = env_var("SystemRoot");
|
||||
let system32: PathBuf = [&windows_dir, "System32"].iter().collect();
|
||||
// Note: This does not use the support wrappers so that we can precisely control the PATH
|
||||
let exe = tmp_dir().join("hello.exe");
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ struct AsyncFdReadyGuard<'a, T> { x: &'a T }
|
|||
|
||||
impl Foo {
|
||||
// @has async_fn/struct.Foo.html
|
||||
// @has - '//*[@class="method"]' 'pub async fn complicated_lifetimes( &self, context: &impl Bar ) -> impl Iterator<Item = &usize>'
|
||||
// @has - '//*[@class="method"]' 'pub async fn complicated_lifetimes( &self, context: &impl Bar, ) -> impl Iterator<Item = &usize>'
|
||||
pub async fn complicated_lifetimes(&self, context: &impl Bar) -> impl Iterator<Item = &usize> {
|
||||
[0].iter()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,2 +1 @@
|
|||
<pre class="rust item-decl"><code>pub fn create(
|
||||
) -> <a class="struct" href="struct.Padding00000000000000000000000000000000000000000000000000000000000000000000000000000000.html" title="struct decl_line_wrapping_empty_arg_list::Padding00000000000000000000000000000000000000000000000000000000000000000000000000000000">Padding00000000000000000000000000000000000000000000000000000000000000000000000000000000</a></code></pre>
|
||||
<pre class="rust item-decl"><code>pub fn create() -> <a class="struct" href="struct.Padding00000000000000000000000000000000000000000000000000000000000000000000000000000000.html" title="struct decl_line_wrapping_empty_arg_list::Padding00000000000000000000000000000000000000000000000000000000000000000000000000000000">Padding00000000000000000000000000000000000000000000000000000000000000000000000000000000</a></code></pre>
|
||||
|
|
@ -3,7 +3,7 @@
|
|||
fn <a href="#tymethod.poll_write" class="fn">poll_write</a>(
|
||||
self,
|
||||
cx: &mut <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="{{channel}}/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>>,
|
||||
buf: &mut [<a class="primitive" href="{{channel}}/std/primitive.usize.html">usize</a>]
|
||||
buf: &mut [<a class="primitive" href="{{channel}}/std/primitive.usize.html">usize</a>],
|
||||
) -> <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="{{channel}}/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="{{channel}}/std/primitive.usize.html">usize</a>, <a class="struct" href="struct.Error.html" title="struct foo::Error">Error</a>>>;
|
||||
<span class="item-spacer" /> fn <a href="#tymethod.poll_flush" class="fn">poll_flush</a>(self, cx: &mut <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="{{channel}}/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>>) -> <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="{{channel}}/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="{{channel}}/std/primitive.unit.html">()</a>, <a class="struct" href="struct.Error.html" title="struct foo::Error">Error</a>>>;
|
||||
<span class="item-spacer" /> fn <a href="#tymethod.poll_close" class="fn">poll_close</a>(self, cx: &mut <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="{{channel}}/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>>) -> <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="{{channel}}/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="{{channel}}/std/primitive.unit.html">()</a>, <a class="struct" href="struct.Error.html" title="struct foo::Error">Error</a>>>;
|
||||
|
|
@ -12,6 +12,6 @@
|
|||
fn <a href="#method.poll_write_vectored" class="fn">poll_write_vectored</a>(
|
||||
self,
|
||||
cx: &mut <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="struct" href="{{channel}}/alloc/string/struct.String.html" title="struct alloc::string::String">String</a>>,
|
||||
bufs: &[<a class="primitive" href="{{channel}}/std/primitive.usize.html">usize</a>]
|
||||
bufs: &[<a class="primitive" href="{{channel}}/std/primitive.usize.html">usize</a>],
|
||||
) -> <a class="enum" href="{{channel}}/core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="{{channel}}/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="{{channel}}/std/primitive.usize.html">usize</a>, <a class="struct" href="struct.Error.html" title="struct foo::Error">Error</a>>> { ... }
|
||||
}</code>
|
||||
|
|
@ -11,7 +11,7 @@ pub use impl_trait_aux::func;
|
|||
// @has impl_trait/fn.func2.html
|
||||
// @has - '//pre[@class="rust item-decl"]' "func2<T>("
|
||||
// @has - '//pre[@class="rust item-decl"]' "_x: impl Deref<Target = Option<T>> + Iterator<Item = T>,"
|
||||
// @has - '//pre[@class="rust item-decl"]' "_y: impl Iterator<Item = u8> )"
|
||||
// @has - '//pre[@class="rust item-decl"]' "_y: impl Iterator<Item = u8>, )"
|
||||
// @!has - '//pre[@class="rust item-decl"]' 'where'
|
||||
pub use impl_trait_aux::func2;
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use std::ops::Add;
|
|||
// @matches foo/fn.function_with_a_really_long_name.html '//*[@class="rust item-decl"]//code' "\
|
||||
// function_with_a_really_long_name\(\n\
|
||||
// \ parameter_one: i32,\n\
|
||||
// \ parameter_two: i32\n\
|
||||
// \ parameter_two: i32,\n\
|
||||
// \) -> Option<i32>$"
|
||||
pub fn function_with_a_really_long_name(parameter_one: i32, parameter_two: i32) -> Option<i32> {
|
||||
Some(parameter_one + parameter_two)
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ pub mod outer {
|
|||
pub use reexports::foo;
|
||||
// @has 'foo/outer/inner/fn.foo_crate.html' '//pre[@class="rust item-decl"]' 'pub(crate) fn foo_crate()'
|
||||
pub(crate) use reexports::foo_crate;
|
||||
// @has 'foo/outer/inner/fn.foo_super.html' '//pre[@class="rust item-decl"]' 'pub(in outer) fn foo_super( )'
|
||||
// @has 'foo/outer/inner/fn.foo_super.html' '//pre[@class="rust item-decl"]' 'pub(in outer) fn foo_super()'
|
||||
pub(super) use::reexports::foo_super;
|
||||
// @!has 'foo/outer/inner/fn.foo_self.html'
|
||||
pub(self) use reexports::foo_self;
|
||||
|
|
|
|||
|
|
@ -1,185 +1,6 @@
|
|||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
= note: older versions of the `rental` crate no longer compile; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: aborting due to 8 previous errors
|
||||
|
||||
Future incompatibility report: Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
error: aborting due to 1 previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -1,44 +0,0 @@
|
|||
PRINT-DERIVE INPUT (DISPLAY): enum ProceduralMasqueradeDummyType { Input, }
|
||||
PRINT-DERIVE RE-COLLECTED (DISPLAY): enum ProceduralMasqueradeDummyType { Input }
|
||||
PRINT-DERIVE INPUT (DEBUG): TokenStream [
|
||||
Ident {
|
||||
ident: "enum",
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:1: 4:5 (#0),
|
||||
},
|
||||
Ident {
|
||||
ident: "ProceduralMasqueradeDummyType",
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6: 4:35 (#0),
|
||||
},
|
||||
Group {
|
||||
delimiter: Brace,
|
||||
stream: TokenStream [
|
||||
Ident {
|
||||
ident: "Input",
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:13:5: 13:10 (#0),
|
||||
},
|
||||
],
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:36: 14:2 (#0),
|
||||
},
|
||||
]
|
||||
PRINT-DERIVE INPUT (DISPLAY): enum ProceduralMasqueradeDummyType { Input, }
|
||||
PRINT-DERIVE RE-COLLECTED (DISPLAY): enum ProceduralMasqueradeDummyType { Input }
|
||||
PRINT-DERIVE INPUT (DEBUG): TokenStream [
|
||||
Ident {
|
||||
ident: "enum",
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:1: 4:5 (#0),
|
||||
},
|
||||
Ident {
|
||||
ident: "ProceduralMasqueradeDummyType",
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6: 4:35 (#0),
|
||||
},
|
||||
Group {
|
||||
delimiter: Brace,
|
||||
stream: TokenStream [
|
||||
Ident {
|
||||
ident: "Input",
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:13:5: 13:10 (#0),
|
||||
},
|
||||
],
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:36: 14:2 (#0),
|
||||
},
|
||||
]
|
||||
|
|
@ -1,185 +1,6 @@
|
|||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
= note: older versions of the `rental` crate no longer compile; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
|
||||
|
||||
error: aborting due to 8 previous errors
|
||||
|
||||
Future incompatibility report: Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
|
||||
Future breakage diagnostic:
|
||||
error: using an old version of `rental`
|
||||
--> $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6
|
||||
|
|
||||
LL | enum ProceduralMasqueradeDummyType {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #83125 <https://github.com/rust-lang/rust/issues/83125>
|
||||
= note: older versions of the `rental` crate will stop compiling in future versions of Rust; please update to `rental` v0.5.6, or switch to one of the `rental` alternatives
|
||||
= note: `#[deny(proc_macro_back_compat)]` on by default
|
||||
error: aborting due to 1 previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -1,44 +0,0 @@
|
|||
PRINT-DERIVE INPUT (DISPLAY): enum ProceduralMasqueradeDummyType { Input, }
|
||||
PRINT-DERIVE RE-COLLECTED (DISPLAY): enum ProceduralMasqueradeDummyType { Input }
|
||||
PRINT-DERIVE INPUT (DEBUG): TokenStream [
|
||||
Ident {
|
||||
ident: "enum",
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:1: 4:5 (#0),
|
||||
},
|
||||
Ident {
|
||||
ident: "ProceduralMasqueradeDummyType",
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:6: 4:35 (#0),
|
||||
},
|
||||
Group {
|
||||
delimiter: Brace,
|
||||
stream: TokenStream [
|
||||
Ident {
|
||||
ident: "Input",
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:13:5: 13:10 (#0),
|
||||
},
|
||||
],
|
||||
span: $DIR/pretty-print-hack/allsorts-rental-0.5.6/src/lib.rs:4:36: 14:2 (#0),
|
||||
},
|
||||
]
|
||||
PRINT-DERIVE INPUT (DISPLAY): enum ProceduralMasqueradeDummyType { Input, }
|
||||
PRINT-DERIVE RE-COLLECTED (DISPLAY): enum ProceduralMasqueradeDummyType { Input }
|
||||
PRINT-DERIVE INPUT (DEBUG): TokenStream [
|
||||
Ident {
|
||||
ident: "enum",
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:1: 4:5 (#0),
|
||||
},
|
||||
Ident {
|
||||
ident: "ProceduralMasqueradeDummyType",
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:6: 4:35 (#0),
|
||||
},
|
||||
Group {
|
||||
delimiter: Brace,
|
||||
stream: TokenStream [
|
||||
Ident {
|
||||
ident: "Input",
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:13:5: 13:10 (#0),
|
||||
},
|
||||
],
|
||||
span: $DIR/pretty-print-hack/rental-0.5.5/src/lib.rs:4:36: 14:2 (#0),
|
||||
},
|
||||
]
|
||||
Loading…
Reference in New Issue