diff --git a/compiler/rustc_builtin_macros/src/alloc_error_handler.rs b/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
index 09d892768b464..1df2812e0c887 100644
--- a/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
+++ b/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
@@ -80,7 +80,7 @@ fn generate_handler(cx: &ExtCtxt<'_>, handler: Ident, span: Span, sig_span: Span
let params = thin_vec![cx.param(span, size, ty_usize.clone()), cx.param(span, align, ty_usize)];
let decl = cx.fn_decl(params, never);
let header = FnHeader { safety: Safety::Unsafe(span), ..FnHeader::default() };
- let sig = FnSig { decl, header, span: span };
+ let sig = FnSig { decl, header, span };
let body = Some(cx.block_expr(call));
let kind = ItemKind::Fn(Box::new(Fn {
diff --git a/compiler/rustc_builtin_macros/src/cfg_eval.rs b/compiler/rustc_builtin_macros/src/cfg_eval.rs
index dc1874bfecbda..4b05c144d37d7 100644
--- a/compiler/rustc_builtin_macros/src/cfg_eval.rs
+++ b/compiler/rustc_builtin_macros/src/cfg_eval.rs
@@ -202,7 +202,7 @@ impl CfgEval<'_> {
}
// Now that we have our re-parsed `AttrTokenStream`, recursively configuring
- // our attribute target will correctly the tokens as well.
+ // our attribute target will correctly configure the tokens as well.
flat_map_annotatable(self, annotatable)
}
}
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index 77da4e4caea0f..b52e6259944d7 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -78,6 +78,7 @@ pub fn from_target_feature(
Some(sym::loongarch_target_feature) => rust_features.loongarch_target_feature,
Some(sym::lahfsahf_target_feature) => rust_features.lahfsahf_target_feature,
Some(sym::prfchw_target_feature) => rust_features.prfchw_target_feature,
+ Some(sym::sha512_sm_x86) => rust_features.sha512_sm_x86,
Some(sym::x86_amx_intrinsics) => rust_features.x86_amx_intrinsics,
Some(sym::xop_target_feature) => rust_features.xop_target_feature,
Some(sym::s390x_target_feature) => rust_features.s390x_target_feature,
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 03210085a12c9..86102bbecd04e 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -591,6 +591,8 @@ declare_features! (
(incomplete, return_type_notation, "1.70.0", Some(109417)),
/// Allows `extern "rust-cold"`.
(unstable, rust_cold_cc, "1.63.0", Some(97544)),
+ /// Allows use of x86 SHA512, SM3 and SM4 target-features and intrinsics
+ (unstable, sha512_sm_x86, "CURRENT_RUSTC_VERSION", Some(126624)),
/// Shortern the tail expression lifetime
(unstable, shorter_tail_lifetimes, "1.79.0", Some(123739)),
/// Allows the use of SIMD types in functions declared in `extern` blocks.
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index f34ef071e21ec..8fdfbcee38546 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -8,7 +8,7 @@ use rustc_span::{sym, BytePos, Span};
use thin_vec::ThinVec;
use tracing::debug;
-use super::{AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, PathStyle};
+use super::{AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, ParserRange, PathStyle};
use crate::{errors, fluent_generated as fluent, maybe_whole};
// Public for rustfmt usage
@@ -313,8 +313,8 @@ impl<'a> Parser<'a> {
// inner attribute, for possible later processing in a `LazyAttrTokenStream`.
if let Capturing::Yes = self.capture_state.capturing {
let end_pos = self.num_bump_calls;
- let range = start_pos..end_pos;
- self.capture_state.inner_attr_ranges.insert(attr.id, range);
+ let parser_range = ParserRange(start_pos..end_pos);
+ self.capture_state.inner_attr_parser_ranges.insert(attr.id, parser_range);
}
attrs.push(attr);
} else {
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index 611dbc0535c61..abf61036c2deb 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -10,7 +10,10 @@ use rustc_errors::PResult;
use rustc_session::parse::ParseSess;
use rustc_span::{sym, Span, DUMMY_SP};
-use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor};
+use super::{
+ Capturing, FlatToken, ForceCollect, NodeRange, NodeReplacement, Parser, ParserRange,
+ TokenCursor,
+};
/// A wrapper type to ensure that the parser handles outer attributes correctly.
/// When we parse outer attributes, we need to ensure that we capture tokens
@@ -28,8 +31,8 @@ use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCurso
#[derive(Debug, Clone)]
pub struct AttrWrapper {
attrs: AttrVec,
- // The start of the outer attributes in the token cursor.
- // This allows us to create a `ReplaceRange` for the entire attribute
+ // The start of the outer attributes in the parser's token stream.
+ // This lets us create a `NodeReplacement` for the entire attribute
// target, including outer attributes.
start_pos: u32,
}
@@ -53,10 +56,9 @@ impl AttrWrapper {
/// Prepend `self.attrs` to `attrs`.
// FIXME: require passing an NT to prevent misuse of this method
- pub(crate) fn prepend_to_nt_inner(self, attrs: &mut AttrVec) {
- let mut self_attrs = self.attrs;
- mem::swap(attrs, &mut self_attrs);
- attrs.extend(self_attrs);
+ pub(crate) fn prepend_to_nt_inner(mut self, attrs: &mut AttrVec) {
+ mem::swap(attrs, &mut self.attrs);
+ attrs.extend(self.attrs);
}
pub fn is_empty(&self) -> bool {
@@ -89,7 +91,7 @@ struct LazyAttrTokenStreamImpl {
cursor_snapshot: TokenCursor,
num_calls: u32,
break_last_token: bool,
- replace_ranges: Box<[ReplaceRange]>,
+ node_replacements: Box<[NodeReplacement]>,
}
impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
@@ -104,21 +106,24 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
.chain(iter::repeat_with(|| FlatToken::Token(cursor_snapshot.next())))
.take(self.num_calls as usize);
- if self.replace_ranges.is_empty() {
+ if self.node_replacements.is_empty() {
make_attr_token_stream(tokens, self.break_last_token)
} else {
let mut tokens: Vec<_> = tokens.collect();
- let mut replace_ranges = self.replace_ranges.to_vec();
- replace_ranges.sort_by_key(|(range, _)| range.start);
+ let mut node_replacements = self.node_replacements.to_vec();
+ node_replacements.sort_by_key(|(range, _)| range.0.start);
#[cfg(debug_assertions)]
- for [(range, tokens), (next_range, next_tokens)] in replace_ranges.array_windows() {
+ for [(node_range, tokens), (next_node_range, next_tokens)] in
+ node_replacements.array_windows()
+ {
assert!(
- range.end <= next_range.start || range.end >= next_range.end,
- "Replace ranges should either be disjoint or nested: ({:?}, {:?}) ({:?}, {:?})",
- range,
+ node_range.0.end <= next_node_range.0.start
+ || node_range.0.end >= next_node_range.0.end,
+ "Node ranges should be disjoint or nested: ({:?}, {:?}) ({:?}, {:?})",
+ node_range,
tokens,
- next_range,
+ next_node_range,
next_tokens,
);
}
@@ -136,20 +141,23 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
// start position, we ensure that any (outer) replace range which
// encloses another (inner) replace range will fully overwrite the
// inner range's replacement.
- for (range, target) in replace_ranges.into_iter().rev() {
- assert!(!range.is_empty(), "Cannot replace an empty range: {range:?}");
+ for (node_range, target) in node_replacements.into_iter().rev() {
+ assert!(
+ !node_range.0.is_empty(),
+ "Cannot replace an empty node range: {:?}",
+ node_range.0
+ );
// Replace the tokens in range with zero or one `FlatToken::AttrsTarget`s, plus
// enough `FlatToken::Empty`s to fill up the rest of the range. This keeps the
// total length of `tokens` constant throughout the replacement process, allowing
- // us to use all of the `ReplaceRanges` entries without adjusting indices.
+ // us to do all replacements without adjusting indices.
let target_len = target.is_some() as usize;
tokens.splice(
- (range.start as usize)..(range.end as usize),
- target
- .into_iter()
- .map(|target| FlatToken::AttrsTarget(target))
- .chain(iter::repeat(FlatToken::Empty).take(range.len() - target_len)),
+ (node_range.0.start as usize)..(node_range.0.end as usize),
+ target.into_iter().map(|target| FlatToken::AttrsTarget(target)).chain(
+ iter::repeat(FlatToken::Empty).take(node_range.0.len() - target_len),
+ ),
);
}
make_attr_token_stream(tokens.into_iter(), self.break_last_token)
@@ -216,7 +224,7 @@ impl<'a> Parser<'a> {
let cursor_snapshot = self.token_cursor.clone();
let start_pos = self.num_bump_calls;
let has_outer_attrs = !attrs.attrs.is_empty();
- let replace_ranges_start = self.capture_state.replace_ranges.len();
+ let parser_replacements_start = self.capture_state.parser_replacements.len();
// We set and restore `Capturing::Yes` on either side of the call to
// `f`, so we can distinguish the outermost call to
@@ -271,7 +279,7 @@ impl<'a> Parser<'a> {
return Ok(ret);
}
- let replace_ranges_end = self.capture_state.replace_ranges.len();
+ let parser_replacements_end = self.capture_state.parser_replacements.len();
assert!(
!(self.break_last_token && capture_trailing),
@@ -288,15 +296,16 @@ impl<'a> Parser<'a> {
let num_calls = end_pos - start_pos;
- // Take the captured ranges for any inner attributes that we parsed in
- // `Parser::parse_inner_attributes`, and pair them in a `ReplaceRange`
- // with `None`, which means the relevant tokens will be removed. (More
- // details below.)
- let mut inner_attr_replace_ranges = Vec::new();
+ // Take the captured `ParserRange`s for any inner attributes that we parsed in
+ // `Parser::parse_inner_attributes`, and pair them in a `ParserReplacement` with `None`,
+ // which means the relevant tokens will be removed. (More details below.)
+ let mut inner_attr_parser_replacements = Vec::new();
for attr in ret.attrs() {
if attr.style == ast::AttrStyle::Inner {
- if let Some(attr_range) = self.capture_state.inner_attr_ranges.remove(&attr.id) {
- inner_attr_replace_ranges.push((attr_range, None));
+ if let Some(inner_attr_parser_range) =
+ self.capture_state.inner_attr_parser_ranges.remove(&attr.id)
+ {
+ inner_attr_parser_replacements.push((inner_attr_parser_range, None));
} else {
self.dcx().span_delayed_bug(attr.span, "Missing token range for attribute");
}
@@ -305,37 +314,41 @@ impl<'a> Parser<'a> {
// This is hot enough for `deep-vector` that checking the conditions for an empty iterator
// is measurably faster than actually executing the iterator.
- let replace_ranges: Box<[ReplaceRange]> =
- if replace_ranges_start == replace_ranges_end && inner_attr_replace_ranges.is_empty() {
- Box::new([])
- } else {
- // Grab any replace ranges that occur *inside* the current AST node. We will
- // perform the actual replacement only when we convert the `LazyAttrTokenStream` to
- // an `AttrTokenStream`.
- self.capture_state.replace_ranges[replace_ranges_start..replace_ranges_end]
- .iter()
- .cloned()
- .chain(inner_attr_replace_ranges.iter().cloned())
- .map(|(range, data)| ((range.start - start_pos)..(range.end - start_pos), data))
- .collect()
- };
+ let node_replacements: Box<[_]> = if parser_replacements_start == parser_replacements_end
+ && inner_attr_parser_replacements.is_empty()
+ {
+ Box::new([])
+ } else {
+ // Grab any replace ranges that occur *inside* the current AST node. Convert them
+ // from `ParserRange` form to `NodeRange` form. We will perform the actual
+ // replacement only when we convert the `LazyAttrTokenStream` to an
+ // `AttrTokenStream`.
+ self.capture_state.parser_replacements
+ [parser_replacements_start..parser_replacements_end]
+ .iter()
+ .cloned()
+ .chain(inner_attr_parser_replacements.iter().cloned())
+ .map(|(parser_range, data)| (NodeRange::new(parser_range, start_pos), data))
+ .collect()
+ };
// What is the status here when parsing the example code at the top of this method?
//
// When parsing `g`:
// - `start_pos..end_pos` is `12..33` (`fn g { ... }`, excluding the outer attr).
- // - `inner_attr_replace_ranges` has one entry (`5..15`, when counting from `fn`), to
+ // - `inner_attr_parser_replacements` has one entry (`ParserRange(17..27)`), to
// delete the inner attr's tokens.
- // - This entry is put into the lazy tokens for `g`, i.e. deleting the inner attr from
- // those tokens (if they get evaluated).
+ // - This entry is converted to `NodeRange(5..15)` (relative to the `fn`) and put into
+ // the lazy tokens for `g`, i.e. deleting the inner attr from those tokens (if they get
+ // evaluated).
// - Those lazy tokens are also put into an `AttrsTarget` that is appended to `self`'s
// replace ranges at the bottom of this function, for processing when parsing `m`.
- // - `replace_ranges_start..replace_ranges_end` is empty.
+ // - `parser_replacements_start..parser_replacements_end` is empty.
//
// When parsing `m`:
// - `start_pos..end_pos` is `0..34` (`mod m`, excluding the `#[cfg_eval]` attribute).
- // - `inner_attr_replace_ranges` is empty.
- // - `replace_range_start..replace_ranges_end` has one entry.
+ // - `inner_attr_parser_replacements` is empty.
+ // - `parser_replacements_start..parser_replacements_end` has one entry.
// - One `AttrsTarget` (added below when parsing `g`) to replace all of `g` (`3..33`,
// including its outer attribute), with:
// - `attrs`: includes the outer and the inner attr.
@@ -346,7 +359,7 @@ impl<'a> Parser<'a> {
num_calls,
cursor_snapshot,
break_last_token: self.break_last_token,
- replace_ranges,
+ node_replacements,
});
// If we support tokens and don't already have them, store the newly captured tokens.
@@ -367,7 +380,7 @@ impl<'a> Parser<'a> {
// What is the status here when parsing the example code at the top of this method?
//
// When parsing `g`, we add one entry:
- // - The `start_pos..end_pos` (`3..33`) entry has a new `AttrsTarget` with:
+ // - The pushed entry (`ParserRange(3..33)`) has a new `AttrsTarget` with:
// - `attrs`: includes the outer and the inner attr.
// - `tokens`: lazy tokens for `g` (with its inner attr deleted).
//
@@ -378,12 +391,14 @@ impl<'a> Parser<'a> {
// cfg-expand this AST node.
let start_pos = if has_outer_attrs { attrs.start_pos } else { start_pos };
let target = AttrsTarget { attrs: ret.attrs().iter().cloned().collect(), tokens };
- self.capture_state.replace_ranges.push((start_pos..end_pos, Some(target)));
+ self.capture_state
+ .parser_replacements
+ .push((ParserRange(start_pos..end_pos), Some(target)));
} else if matches!(self.capture_state.capturing, Capturing::No) {
// Only clear the ranges once we've finished capturing entirely, i.e. we've finished
// the outermost call to this method.
- self.capture_state.replace_ranges.clear();
- self.capture_state.inner_attr_ranges.clear();
+ self.capture_state.parser_replacements.clear();
+ self.capture_state.inner_attr_parser_ranges.clear();
}
Ok(ret)
}
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 1b053c39e64b4..ccf8dcdf0b6f2 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -40,14 +40,6 @@ use super::{
};
use crate::{errors, maybe_recover_from_interpolated_ty_qpath};
-#[derive(Debug)]
-pub(super) enum LhsExpr {
- // Already parsed just the outer attributes.
- Unparsed { attrs: AttrWrapper },
- // Already parsed the expression.
- Parsed { expr: P<Expr>, starts_statement: bool },
-}
-
#[derive(Debug)]
enum DestructuredFloat {
/// 1e2
@@ -113,30 +105,31 @@ impl<'a> Parser<'a> {
r: Restrictions,
attrs: AttrWrapper,
) -> PResult<'a, P<Expr>> {
- self.with_res(r, |this| this.parse_expr_assoc_with(0, LhsExpr::Unparsed { attrs }))
+ self.with_res(r, |this| this.parse_expr_assoc_with(0, attrs))
}
/// Parses an associative expression with operators of at least `min_prec` precedence.
pub(super) fn parse_expr_assoc_with(
&mut self,
min_prec: usize,
- lhs: LhsExpr,
+ attrs: AttrWrapper,
) -> PResult<'a, P<Expr>> {
- let mut starts_stmt = false;
- let mut lhs = match lhs {
- LhsExpr::Parsed { expr, starts_statement } => {
- starts_stmt = starts_statement;
- expr
- }
- LhsExpr::Unparsed { attrs } => {
- if self.token.is_range_separator() {
- return self.parse_expr_prefix_range(attrs);
- } else {
- self.parse_expr_prefix(attrs)?
- }
- }
+ let lhs = if self.token.is_range_separator() {
+ return self.parse_expr_prefix_range(attrs);
+ } else {
+ self.parse_expr_prefix(attrs)?
};
+ self.parse_expr_assoc_rest_with(min_prec, false, lhs)
+ }
+ /// Parses the rest of an associative expression (i.e. the part after the lhs) with operators
+ /// of at least `min_prec` precedence.
+ pub(super) fn parse_expr_assoc_rest_with(
+ &mut self,
+ min_prec: usize,
+ starts_stmt: bool,
+ mut lhs: P<Expr>,
+ ) -> PResult<'a, P<Expr>> {
if !self.should_continue_as_assoc_expr(&lhs) {
return Ok(lhs);
}
@@ -272,7 +265,7 @@ impl<'a> Parser<'a> {
};
let rhs = self.with_res(restrictions - Restrictions::STMT_EXPR, |this| {
let attrs = this.parse_outer_attributes()?;
- this.parse_expr_assoc_with(prec + prec_adjustment, LhsExpr::Unparsed { attrs })
+ this.parse_expr_assoc_with(prec + prec_adjustment, attrs)
})?;
let span = self.mk_expr_sp(&lhs, lhs_span, rhs.span);
@@ -447,7 +440,7 @@ impl<'a> Parser<'a> {
let maybe_lt = self.token.clone();
let attrs = self.parse_outer_attributes()?;
Some(
- self.parse_expr_assoc_with(prec + 1, LhsExpr::Unparsed { attrs })
+ self.parse_expr_assoc_with(prec + 1, attrs)
.map_err(|err| self.maybe_err_dotdotlt_syntax(maybe_lt, err))?,
)
} else {
@@ -504,12 +497,9 @@ impl<'a> Parser<'a> {
let (span, opt_end) = if this.is_at_start_of_range_notation_rhs() {
// RHS must be parsed with more associativity than the dots.
let attrs = this.parse_outer_attributes()?;
- this.parse_expr_assoc_with(
- op.unwrap().precedence() + 1,
- LhsExpr::Unparsed { attrs },
- )
- .map(|x| (lo.to(x.span), Some(x)))
- .map_err(|err| this.maybe_err_dotdotlt_syntax(maybe_lt, err))?
+ this.parse_expr_assoc_with(op.unwrap().precedence() + 1, attrs)
+ .map(|x| (lo.to(x.span), Some(x)))
+ .map_err(|err| this.maybe_err_dotdotlt_syntax(maybe_lt, err))?
} else {
(lo, None)
};
@@ -889,7 +879,7 @@ impl<'a> Parser<'a> {
mut e: P<Expr>,
lo: Span,
) -> PResult<'a, P<Expr>> {
- let res = ensure_sufficient_stack(|| {
+ let mut res = ensure_sufficient_stack(|| {
loop {
let has_question =
if self.prev_token.kind == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
@@ -936,17 +926,13 @@ impl<'a> Parser<'a> {
// Stitch the list of outer attributes onto the return value. A little
// bit ugly, but the best way given the current code structure.
- if attrs.is_empty() {
- res
- } else {
- res.map(|expr| {
- expr.map(|mut expr| {
- attrs.extend(expr.attrs);
- expr.attrs = attrs;
- expr
- })
- })
+ if !attrs.is_empty()
+ && let Ok(expr) = &mut res
+ {
+ mem::swap(&mut expr.attrs, &mut attrs);
+ expr.attrs.extend(attrs)
}
+ res
}
pub(super) fn parse_dot_suffix_expr(
@@ -2647,10 +2633,7 @@ impl<'a> Parser<'a> {
self.expect(&token::Eq)?;
}
let attrs = self.parse_outer_attributes()?;
- let expr = self.parse_expr_assoc_with(
- 1 + prec_let_scrutinee_needs_par(),
- LhsExpr::Unparsed { attrs },
- )?;
+ let expr = self.parse_expr_assoc_with(1 + prec_let_scrutinee_needs_par(), attrs)?;
let span = lo.to(expr.span);
Ok(self.mk_expr(span, ExprKind::Let(pat, expr, span, recovered)))
}
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index e01f605722b72..0fbf8c0fbcbbc 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -192,24 +192,54 @@ struct ClosureSpans {
body: Span,
}
-/// Indicates a range of tokens that should be replaced by
-/// the tokens in the provided `AttrsTarget`. This is used in two
-/// places during token collection:
+/// A token range within a `Parser`'s full token stream.
+#[derive(Clone, Debug)]
+struct ParserRange(Range<u32>);
+
+/// A token range within an individual AST node's (lazy) token stream, i.e.
+/// relative to that node's first token. Distinct from `ParserRange` so the two
+/// kinds of range can't be mixed up.
+#[derive(Clone, Debug)]
+struct NodeRange(Range<u32>);
+
+/// Indicates a range of tokens that should be replaced by an `AttrsTarget`
+/// (replacement) or be replaced by nothing (deletion). This is used in two
+/// places during token collection.
+///
+/// 1. Replacement. During the parsing of an AST node that may have a
+/// `#[derive]` attribute, when we parse a nested AST node that has `#[cfg]`
+/// or `#[cfg_attr]`, we replace the entire inner AST node with
+/// `FlatToken::AttrsTarget`. This lets us perform eager cfg-expansion on an
+/// `AttrTokenStream`.
///
-/// 1. During the parsing of an AST node that may have a `#[derive]`
-/// attribute, we parse a nested AST node that has `#[cfg]` or `#[cfg_attr]`
-/// In this case, we use a `ReplaceRange` to replace the entire inner AST node
-/// with `FlatToken::AttrsTarget`, allowing us to perform eager cfg-expansion
-/// on an `AttrTokenStream`.
+/// 2. Deletion. We delete inner attributes from all collected token streams,
+/// and instead track them through the `attrs` field on the AST node. This
+/// lets us manipulate them similarly to outer attributes. When we create a
+/// `TokenStream`, the inner attributes are inserted into the proper place
+/// in the token stream.
///
-/// 2. When we parse an inner attribute while collecting tokens. We
-/// remove inner attributes from the token stream entirely, and
-/// instead track them through the `attrs` field on the AST node.
-/// This allows us to easily manipulate them (for example, removing
-/// the first macro inner attribute to invoke a proc-macro).
-/// When create a `TokenStream`, the inner attributes get inserted
-/// into the proper place in the token stream.
-type ReplaceRange = (Range<u32>, Option<AttrsTarget>);
+/// Each replacement starts off in `ParserReplacement` form but is converted to
+/// `NodeReplacement` form when it is attached to a single AST node, via
+/// `LazyAttrTokenStreamImpl`.
+type ParserReplacement = (ParserRange, Option<AttrsTarget>);
+
+/// See the comment on `ParserReplacement`.
+type NodeReplacement = (NodeRange, Option<AttrsTarget>);
+
+impl NodeRange {
+ // Converts a range within a parser's tokens to a range within a
+ // node's tokens beginning at `start_pos`.
+ //
+ // For example, imagine a parser with 50 tokens in its token stream, a
+ // function that spans `ParserRange(20..40)` and an inner attribute within
+ // that function that spans `ParserRange(30..35)`. We would find the inner
+ // attribute's range within the function's tokens by subtracting 20, which
+ // is the position of the function's start token. This gives
+ // `NodeRange(10..15)`.
+ fn new(ParserRange(parser_range): ParserRange, start_pos: u32) -> NodeRange {
+ NodeRange((parser_range.start - start_pos)..(parser_range.end - start_pos))
+ }
+}
/// Controls how we capture tokens. Capturing can be expensive,
/// so we try to avoid performing capturing in cases where
@@ -226,8 +256,8 @@ enum Capturing {
#[derive(Clone, Debug)]
struct CaptureState {
capturing: Capturing,
- replace_ranges: Vec<ReplaceRange>,
- inner_attr_ranges: FxHashMap<AttrId, Range<u32>>,
+ parser_replacements: Vec<ParserReplacement>,
+ inner_attr_parser_ranges: FxHashMap<AttrId, ParserRange>,
}
/// Iterator over a `TokenStream` that produces `Token`s. It's a bit odd that
@@ -417,8 +447,8 @@ impl<'a> Parser<'a> {
subparser_name,
capture_state: CaptureState {
capturing: Capturing::No,
- replace_ranges: Vec::new(),
- inner_attr_ranges: Default::default(),
+ parser_replacements: Vec::new(),
+ inner_attr_parser_ranges: Default::default(),
},
current_closure: None,
recovery: Recovery::Allowed,
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index b6f85cc90324c..5bfb8bdf776a0 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -25,7 +25,7 @@ use crate::errors::{
UnexpectedParenInRangePat, UnexpectedParenInRangePatSugg,
UnexpectedVertVertBeforeFunctionParam, UnexpectedVertVertInPattern, WrapInParens,
};
-use crate::parser::expr::{could_be_unclosed_char_literal, LhsExpr};
+use crate::parser::expr::could_be_unclosed_char_literal;
use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
#[derive(PartialEq, Copy, Clone)]
@@ -403,8 +403,9 @@ impl<'a> Parser<'a> {
// Parse an associative expression such as `+ expr`, `% expr`, ...
// Assignements, ranges and `|` are disabled by [`Restrictions::IS_PAT`].
- let lhs = LhsExpr::Parsed { expr, starts_statement: false };
- if let Ok(expr) = snapshot.parse_expr_assoc_with(0, lhs).map_err(|err| err.cancel()) {
+ if let Ok(expr) =
+ snapshot.parse_expr_assoc_rest_with(0, false, expr).map_err(|err| err.cancel())
+ {
// We got a valid expression.
self.restore_snapshot(snapshot);
self.restrictions.remove(Restrictions::IS_PAT);
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 7b0daaa14335f..b3efb87a4a26a 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -17,7 +17,6 @@ use thin_vec::{thin_vec, ThinVec};
use super::attr::InnerAttrForbiddenReason;
use super::diagnostics::AttemptLocalParseRecovery;
-use super::expr::LhsExpr;
use super::pat::{PatternLocation, RecoverComma};
use super::path::PathStyle;
use super::{
@@ -66,7 +65,12 @@ impl<'a> Parser<'a> {
}
Ok(Some(if self.token.is_keyword(kw::Let) {
- self.parse_local_mk(lo, attrs, capture_semi, force_collect)?
+ self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
+ this.expect_keyword(kw::Let)?;
+ let local = this.parse_local(attrs)?;
+ let trailing = capture_semi && this.token.kind == token::Semi;
+ Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
+ })?
} else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
self.recover_stmt_local_after_let(
lo,
@@ -112,13 +116,12 @@ impl<'a> Parser<'a> {
}
}
} else if let Some(item) = self.parse_item_common(
- attrs.clone(),
+ attrs.clone(), // FIXME: unwanted clone of attrs
false,
true,
FnParseMode { req_name: |_| true, req_body: true },
force_collect,
)? {
- // FIXME: Bad copy of attrs
self.mk_stmt(lo.to(item.span), StmtKind::Item(P(item)))
} else if self.eat(&token::Semi) {
// Do not attempt to parse an expression if we're done here.
@@ -173,7 +176,7 @@ impl<'a> Parser<'a> {
// Perform this outside of the `collect_tokens_trailing_token` closure,
// since our outer attributes do not apply to this part of the expression
let expr = self.with_res(Restrictions::STMT_EXPR, |this| {
- this.parse_expr_assoc_with(0, LhsExpr::Parsed { expr, starts_statement: true })
+ this.parse_expr_assoc_rest_with(0, true, expr)
})?;
Ok(self.mk_stmt(lo.to(self.prev_token.span), StmtKind::Expr(expr)))
} else {
@@ -206,8 +209,7 @@ impl<'a> Parser<'a> {
let e = self.mk_expr(lo.to(hi), ExprKind::MacCall(mac));
let e = self.maybe_recover_from_bad_qpath(e)?;
let e = self.parse_expr_dot_or_call_with(attrs, e, lo)?;
- let e = self
- .parse_expr_assoc_with(0, LhsExpr::Parsed { expr: e, starts_statement: false })?;
+ let e = self.parse_expr_assoc_rest_with(0, false, e)?;
StmtKind::Expr(e)
};
Ok(self.mk_stmt(lo.to(hi), kind))
@@ -247,21 +249,6 @@ impl<'a> Parser<'a> {
Ok(stmt)
}
- fn parse_local_mk(
- &mut self,
- lo: Span,
- attrs: AttrWrapper,
- capture_semi: bool,
- force_collect: ForceCollect,
- ) -> PResult<'a, Stmt> {
- self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
- this.expect_keyword(kw::Let)?;
- let local = this.parse_local(attrs)?;
- let trailing = capture_semi && this.token.kind == token::Semi;
- Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
- })
- }
-
/// Parses a local variable declaration.
fn parse_local(&mut self, attrs: AttrVec) -> PResult<'a, P<Local>> {
let lo = self.prev_token.span;
diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs
index 8a931fc4158e3..7ae5c9040042c 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -17,7 +17,7 @@ use rustc_hir::{Node, PatKind, TyKind};
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::middle::privacy::Level;
use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, AssocItemContainer, TyCtxt};
+use rustc_middle::ty::{self, TyCtxt};
use rustc_middle::{bug, span_bug};
use rustc_session::lint;
use rustc_session::lint::builtin::DEAD_CODE;
@@ -44,79 +44,16 @@ fn should_explore(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
)
}
-struct Publicness {
- ty_is_public: bool,
- ty_and_all_fields_are_public: bool,
-}
-
-impl Publicness {
- fn new(ty_is_public: bool, ty_and_all_fields_are_public: bool) -> Self {
- Self { ty_is_public, ty_and_all_fields_are_public }
- }
-}
-
-fn adt_of<'tcx>(ty: &hir::Ty<'tcx>) -> Option<(LocalDefId, DefKind)> {
- match ty.kind {
- TyKind::Path(hir::QPath::Resolved(_, path)) => {
- if let Res::Def(def_kind, def_id) = path.res
- && let Some(local_def_id) = def_id.as_local()
- {
- Some((local_def_id, def_kind))
- } else {
- None
- }
- }
- TyKind::Slice(ty) | TyKind::Array(ty, _) => adt_of(ty),
- TyKind::Ptr(ty) | TyKind::Ref(_, ty) => adt_of(ty.ty),
- _ => None,
- }
-}
-
-fn struct_all_fields_are_public(tcx: TyCtxt<'_>, id: LocalDefId) -> bool {
- let adt_def = tcx.adt_def(id);
-
- // skip types contain fields of unit and never type,
- // it's usually intentional to make the type not constructible
- let not_require_constructor = adt_def.all_fields().any(|field| {
- let field_type = tcx.type_of(field.did).instantiate_identity();
- field_type.is_unit() || field_type.is_never()
- });
-
- not_require_constructor
- || adt_def.all_fields().all(|field| {
- let field_type = tcx.type_of(field.did).instantiate_identity();
- // skip fields of PhantomData,
- // cause it's a common way to check things like well-formedness
- if field_type.is_phantom_data() {
- return true;
- }
-
- field.vis.is_public()
- })
-}
-
-/// check struct and its fields are public or not,
-/// for enum and union, just check they are public,
-/// and doesn't solve types like &T for now, just skip them
-fn ty_ref_to_pub_struct(tcx: TyCtxt<'_>, ty: &hir::Ty<'_>) -> Publicness {
- if let Some((def_id, def_kind)) = adt_of(ty) {
- return match def_kind {
- DefKind::Enum | DefKind::Union => {
- let ty_is_public = tcx.visibility(def_id).is_public();
- Publicness::new(ty_is_public, ty_is_public)
- }
- DefKind::Struct => {
- let ty_is_public = tcx.visibility(def_id).is_public();
- Publicness::new(
- ty_is_public,
- ty_is_public && struct_all_fields_are_public(tcx, def_id),
- )
- }
- _ => Publicness::new(true, true),
- };
+fn ty_ref_to_pub_struct(tcx: TyCtxt<'_>, ty: &hir::Ty<'_>) -> bool {
+ if let TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
+ && let Res::Def(def_kind, def_id) = path.res
+ && def_id.is_local()
+ && matches!(def_kind, DefKind::Struct | DefKind::Enum | DefKind::Union)
+ {
+ tcx.visibility(def_id).is_public()
+ } else {
+ true
}
-
- Publicness::new(true, true)
}
/// Determine if a work from the worklist is coming from a `#[allow]`
@@ -172,10 +109,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
fn handle_res(&mut self, res: Res) {
match res {
- Res::Def(
- DefKind::Const | DefKind::AssocConst | DefKind::AssocTy | DefKind::TyAlias,
- def_id,
- ) => {
+ Res::Def(DefKind::Const | DefKind::AssocConst | DefKind::TyAlias, def_id) => {
self.check_def_id(def_id);
}
_ if self.in_pat => {}
@@ -294,10 +228,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
pats: &[hir::PatField<'_>],
) {
let variant = match self.typeck_results().node_type(lhs.hir_id).kind() {
- ty::Adt(adt, _) => {
- self.check_def_id(adt.did());
- adt.variant_of_res(res)
- }
+ ty::Adt(adt, _) => adt.variant_of_res(res),
_ => span_bug!(lhs.span, "non-ADT in struct pattern"),
};
for pat in pats {
@@ -317,10 +248,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
dotdot: hir::DotDotPos,
) {
let variant = match self.typeck_results().node_type(lhs.hir_id).kind() {
- ty::Adt(adt, _) => {
- self.check_def_id(adt.did());
- adt.variant_of_res(res)
- }
+ ty::Adt(adt, _) => adt.variant_of_res(res),
_ => {
self.tcx.dcx().span_delayed_bug(lhs.span, "non-ADT in tuple struct pattern");
return;
@@ -425,6 +353,31 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
return false;
}
+ // don't ignore impls for Enums and pub Structs whose methods don't have self receiver,
+ // cause external crate may call such methods to construct values of these types
+ if let Some(local_impl_of) = impl_of.as_local()
+ && let Some(local_def_id) = def_id.as_local()
+ && let Some(fn_sig) =
+ self.tcx.hir().fn_sig_by_hir_id(self.tcx.local_def_id_to_hir_id(local_def_id))
+ && matches!(fn_sig.decl.implicit_self, hir::ImplicitSelfKind::None)
+ && let TyKind::Path(hir::QPath::Resolved(_, path)) =
+ self.tcx.hir().expect_item(local_impl_of).expect_impl().self_ty.kind
+ && let Res::Def(def_kind, did) = path.res
+ {
+ match def_kind {
+ // for example, #[derive(Default)] pub struct T(i32);
+ // external crate can call T::default() to construct T,
+ // so that don't ignore impl Default for pub Enum and Structs
+ DefKind::Struct | DefKind::Union if self.tcx.visibility(did).is_public() => {
+ return false;
+ }
+ // don't ignore impl Default for Enums,
+ // cause we don't know which variant is constructed
+ DefKind::Enum => return false,
+ _ => (),
+ };
+ }
+
if let Some(trait_of) = self.tcx.trait_id_of_impl(impl_of)
&& self.tcx.has_attr(trait_of, sym::rustc_trivial_field_reads)
{
@@ -467,7 +420,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
intravisit::walk_item(self, item)
}
hir::ItemKind::ForeignMod { .. } => {}
- hir::ItemKind::Trait(_, _, _, _, trait_item_refs) => {
+ hir::ItemKind::Trait(..) => {
for impl_def_id in self.tcx.all_impls(item.owner_id.to_def_id()) {
if let Some(local_def_id) = impl_def_id.as_local()
&& let ItemKind::Impl(impl_ref) =
@@ -480,12 +433,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
intravisit::walk_path(self, impl_ref.of_trait.unwrap().path);
}
}
- // mark assoc ty live if the trait is live
- for trait_item in trait_item_refs {
- if let hir::AssocItemKind::Type = trait_item.kind {
- self.check_def_id(trait_item.id.owner_id.to_def_id());
- }
- }
+
intravisit::walk_item(self, item)
}
_ => intravisit::walk_item(self, item),
@@ -502,12 +450,11 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
&& let ItemKind::Impl(impl_ref) =
self.tcx.hir().expect_item(local_impl_id).kind
{
- if !ty_ref_to_pub_struct(self.tcx, impl_ref.self_ty)
- .ty_and_all_fields_are_public
+ if !matches!(trait_item.kind, hir::TraitItemKind::Type(..))
+ && !ty_ref_to_pub_struct(self.tcx, impl_ref.self_ty)
{
- // skip impl-items of non pure pub ty,
- // cause we don't know the ty is constructed or not,
- // check these later in `solve_rest_impl_items`
+ // skip methods of private ty,
+ // they would be solved in `solve_rest_impl_items`
continue;
}
@@ -582,25 +529,28 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
}
fn impl_item_with_used_self(&mut self, impl_id: hir::ItemId, impl_item_id: LocalDefId) -> bool {
- if let Some((local_def_id, def_kind)) =
- adt_of(self.tcx.hir().item(impl_id).expect_impl().self_ty)
+ if let TyKind::Path(hir::QPath::Resolved(_, path)) =
+ self.tcx.hir().item(impl_id).expect_impl().self_ty.kind
+ && let Res::Def(def_kind, def_id) = path.res
+ && let Some(local_def_id) = def_id.as_local()
&& matches!(def_kind, DefKind::Struct | DefKind::Enum | DefKind::Union)
{
+ if self.tcx.visibility(impl_item_id).is_public() {
+ // for the public method, we don't know the trait item is used or not,
+ // so we mark the method live if the self is used
+ return self.live_symbols.contains(&local_def_id);
+ }
+
if let Some(trait_item_id) = self.tcx.associated_item(impl_item_id).trait_item_def_id
&& let Some(local_id) = trait_item_id.as_local()
{
- // for the local impl item, we can know the trait item is used or not,
+ // for the private method, we can know the trait item is used or not,
// so we mark the method live if the self is used and the trait item is used
- self.live_symbols.contains(&local_id) && self.live_symbols.contains(&local_def_id)
- } else {
- // for the foreign method and inherent pub method,
- // we don't know the trait item or the method is used or not,
- // so we mark the method live if the self is used
- self.live_symbols.contains(&local_def_id)
+ return self.live_symbols.contains(&local_id)
+ && self.live_symbols.contains(&local_def_id);
}
- } else {
- false
}
+ false
}
}
@@ -686,9 +636,6 @@ impl<'tcx> Visitor<'tcx> for MarkSymbolVisitor<'tcx> {
self.handle_field_pattern_match(pat, res, fields);
}
PatKind::Path(ref qpath) => {
- if let ty::Adt(adt, _) = self.typeck_results().node_type(pat.hir_id).kind() {
- self.check_def_id(adt.did());
- }
let res = self.typeck_results().qpath_res(qpath, pat.hir_id);
self.handle_res(res);
}
@@ -825,9 +772,7 @@ fn check_item<'tcx>(
.iter()
.filter_map(|def_id| def_id.as_local());
- let self_ty = tcx.hir().item(id).expect_impl().self_ty;
- let Publicness { ty_is_public, ty_and_all_fields_are_public } =
- ty_ref_to_pub_struct(tcx, self_ty);
+ let ty_is_pub = ty_ref_to_pub_struct(tcx, tcx.hir().item(id).expect_impl().self_ty);
// And we access the Map here to get HirId from LocalDefId
for local_def_id in local_def_ids {
@@ -843,19 +788,18 @@ fn check_item<'tcx>(
// for trait impl blocks,
// mark the method live if the self_ty is public,
// or the method is public and may construct self
- if tcx.visibility(local_def_id).is_public()
- && (ty_and_all_fields_are_public || (ty_is_public && may_construct_self))
+ if of_trait
+ && (!matches!(tcx.def_kind(local_def_id), DefKind::AssocFn)
+ || tcx.visibility(local_def_id).is_public()
+ && (ty_is_pub || may_construct_self))
{
- // if the impl item is public,
- // and the ty may be constructed or can be constructed in foreign crates,
- // mark the impl item live
worklist.push((local_def_id, ComesFromAllowExpect::No));
} else if let Some(comes_from_allow) =
has_allow_dead_code_or_lang_attr(tcx, local_def_id)
{
worklist.push((local_def_id, comes_from_allow));
- } else if of_trait || tcx.visibility(local_def_id).is_public() && ty_is_public {
- // private impl items of traits || public impl items not constructs self
+ } else if of_trait {
+ // private method || public method not constructs self
unsolved_impl_items.push((id, local_def_id));
}
}
@@ -881,13 +825,10 @@ fn check_trait_item(
worklist: &mut Vec<(LocalDefId, ComesFromAllowExpect)>,
id: hir::TraitItemId,
) {
- use hir::TraitItemKind::{Const, Fn, Type};
- if matches!(
- tcx.def_kind(id.owner_id),
- DefKind::AssocConst | DefKind::AssocTy | DefKind::AssocFn
- ) {
+ use hir::TraitItemKind::{Const, Fn};
+ if matches!(tcx.def_kind(id.owner_id), DefKind::AssocConst | DefKind::AssocFn) {
let trait_item = tcx.hir().trait_item(id);
- if matches!(trait_item.kind, Const(_, Some(_)) | Type(_, Some(_)) | Fn(..))
+ if matches!(trait_item.kind, Const(_, Some(_)) | Fn(..))
&& let Some(comes_from_allow) =
has_allow_dead_code_or_lang_attr(tcx, trait_item.owner_id.def_id)
{
@@ -925,14 +866,6 @@ fn create_and_seed_worklist(
effective_vis
.is_public_at_level(Level::Reachable)
.then_some(id)
- .filter(|&id|
- // checks impls, impl-items and pub structs with all public fields later
- match tcx.def_kind(id) {
- DefKind::Impl { .. } => false,
- DefKind::AssocConst | DefKind::AssocTy | DefKind::AssocFn => !matches!(tcx.associated_item(id).container, AssocItemContainer::ImplContainer),
- DefKind::Struct => struct_all_fields_are_public(tcx, id) || has_allow_dead_code_or_lang_attr(tcx, id).is_some(),
- _ => true
- })
.map(|id| (id, ComesFromAllowExpect::No))
})
// Seed entry point
@@ -1216,7 +1149,6 @@ impl<'tcx> DeadVisitor<'tcx> {
}
match self.tcx.def_kind(def_id) {
DefKind::AssocConst
- | DefKind::AssocTy
| DefKind::AssocFn
| DefKind::Fn
| DefKind::Static { .. }
@@ -1258,14 +1190,10 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
|| (def_kind == DefKind::Trait && live_symbols.contains(&item.owner_id.def_id))
{
for &def_id in tcx.associated_item_def_ids(item.owner_id.def_id) {
- // We have diagnosed unused assocs in traits
+ // We have diagnosed unused methods in traits
if matches!(def_kind, DefKind::Impl { of_trait: true })
- && matches!(tcx.def_kind(def_id), DefKind::AssocConst | DefKind::AssocTy | DefKind::AssocFn)
- // skip unused public inherent methods,
- // cause we have diagnosed unconstructed struct
- || matches!(def_kind, DefKind::Impl { of_trait: false })
- && tcx.visibility(def_id).is_public()
- && ty_ref_to_pub_struct(tcx, tcx.hir().item(item).expect_impl().self_ty).ty_is_public
+ && tcx.def_kind(def_id) == DefKind::AssocFn
+ || def_kind == DefKind::Trait && tcx.def_kind(def_id) != DefKind::AssocFn
{
continue;
}
diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs
index 761d6acdbaeb9..ca3efc11201e1 100644
--- a/compiler/rustc_query_system/src/query/job.rs
+++ b/compiler/rustc_query_system/src/query/job.rs
@@ -588,7 +588,7 @@ pub fn report_cycle<'a>(
cycle_stack,
stack_bottom: stack[0].query.description.to_owned(),
alias,
- cycle_usage: cycle_usage,
+ cycle_usage,
stack_count,
note_span: (),
};
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index e8563f50158a5..9977fa7425a3e 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1705,6 +1705,7 @@ symbols! {
self_in_typedefs,
self_struct_ctor,
semitransparent,
+ sha512_sm_x86,
shadow_call_stack,
shl,
shl_assign,
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 532507cb18244..e52f2fc06df06 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -238,6 +238,9 @@ const X86_ALLOWED_FEATURES: &[(&str, Stability)] = &[
("rdseed", Stable),
("rtm", Unstable(sym::rtm_target_feature)),
("sha", Stable),
+ ("sha512", Unstable(sym::sha512_sm_x86)),
+ ("sm3", Unstable(sym::sha512_sm_x86)),
+ ("sm4", Unstable(sym::sha512_sm_x86)),
("sse", Stable),
("sse2", Stable),
("sse3", Stable),
diff --git a/library/core/src/arch.rs b/library/core/src/arch.rs
index 31d6bc36fc8b9..d681bd124fe13 100644
--- a/library/core/src/arch.rs
+++ b/library/core/src/arch.rs
@@ -4,6 +4,15 @@
#[stable(feature = "simd_arch", since = "1.27.0")]
pub use crate::core_arch::arch::*;
+#[cfg(bootstrap)]
+#[allow(dead_code)]
+#[unstable(feature = "sha512_sm_x86", issue = "126624")]
+fn dummy() {
+ // AArch64 also has a target feature named `sm4`, so we need `#![feature(sha512_sm_x86)]` in lib.rs
+ // But as the bootstrap compiler doesn't know about this feature yet, we need to convert it to a
+ // library feature until bootstrap gets bumped
+}
+
/// Inline assembly.
///
/// Refer to [Rust By Example] for a usage guide and the [reference] for
diff --git a/library/core/src/default.rs b/library/core/src/default.rs
index 4524b352ec817..5cacedcb241a5 100644
--- a/library/core/src/default.rs
+++ b/library/core/src/default.rs
@@ -103,6 +103,7 @@ use crate::ascii::Char as AsciiChar;
/// ```
#[cfg_attr(not(test), rustc_diagnostic_item = "Default")]
#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg_attr(not(bootstrap), rustc_trivial_field_reads)]
pub trait Default: Sized {
/// Returns the "default value" for a type.
///
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 0917631e04500..9306581dca93d 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -260,6 +260,7 @@
#![feature(powerpc_target_feature)]
#![feature(riscv_target_feature)]
#![feature(rtm_target_feature)]
+#![feature(sha512_sm_x86)]
#![feature(sse4a_target_feature)]
#![feature(tbm_target_feature)]
#![feature(wasm_target_feature)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 37ba7e7065d4b..37417f38b5448 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -269,10 +269,6 @@
#![cfg_attr(any(windows, target_os = "uefi"), feature(round_char_boundary))]
#![cfg_attr(target_family = "wasm", feature(stdarch_wasm_atomic_wait))]
#![cfg_attr(target_arch = "wasm64", feature(simd_wasm64))]
-#![cfg_attr(
- all(any(target_arch = "x86_64", target_arch = "x86"), target_os = "uefi"),
- feature(stdarch_x86_has_cpuid)
-)]
//
// Language features:
// tidy-alphabetical-start
diff --git a/library/std/src/sys/pal/uefi/time.rs b/library/std/src/sys/pal/uefi/time.rs
index a97d69f997bf9..495ff2dc930ed 100644
--- a/library/std/src/sys/pal/uefi/time.rs
+++ b/library/std/src/sys/pal/uefi/time.rs
@@ -175,10 +175,6 @@ pub(crate) mod instant_internal {
#[cfg(target_arch = "x86_64")]
fn timestamp_rdtsc() -> Option<Duration> {
- if !crate::arch::x86_64::has_cpuid() {
- return None;
- }
-
static FREQUENCY: crate::sync::OnceLock<u64> = crate::sync::OnceLock::new();
// Get Frequency in Mhz
@@ -200,10 +196,6 @@ pub(crate) mod instant_internal {
#[cfg(target_arch = "x86")]
fn timestamp_rdtsc() -> Option<Duration> {
- if !crate::arch::x86::has_cpuid() {
- return None;
- }
-
static FREQUENCY: crate::sync::OnceLock<u64> = crate::sync::OnceLock::new();
let freq = FREQUENCY
diff --git a/library/std/src/sys/pal/unix/pipe.rs b/library/std/src/sys/pal/unix/pipe.rs
index 8762af614f17e..f0ebc767badad 100644
--- a/library/std/src/sys/pal/unix/pipe.rs
+++ b/library/std/src/sys/pal/unix/pipe.rs
@@ -47,6 +47,8 @@ pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
}
impl AnonPipe {
+ #[allow(dead_code)]
+ // FIXME: This function seems legitimately unused.
pub fn try_clone(&self) -> io::Result<Self> {
self.0.duplicate().map(Self)
}
@@ -85,6 +87,8 @@ impl AnonPipe {
self.0.is_write_vectored()
}
+ #[allow(dead_code)]
+ // FIXME: This function seems legitimately unused.
pub fn as_file_desc(&self) -> &FileDesc {
&self.0
}
diff --git a/src/tools/compiletest/src/command-list.rs b/src/tools/compiletest/src/command-list.rs
index 288f90ea12399..0706f3bee05c1 100644
--- a/src/tools/compiletest/src/command-list.rs
+++ b/src/tools/compiletest/src/command-list.rs
@@ -18,6 +18,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
"check-test-line-numbers-match",
"compare-output-lines-by-subset",
"compile-flags",
+ "doc-flags",
"dont-check-compiler-stderr",
"dont-check-compiler-stdout",
"dont-check-failure-status",
@@ -226,6 +227,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
"should-ice",
"stderr-per-bitwidth",
"test-mir-pass",
+ "unique-doc-out-dir",
"unset-exec-env",
"unset-rustc-env",
// Used by the tidy check `unknown_revision`.
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index cde3e3295c631..1fc24301c85e6 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -95,6 +95,8 @@ pub struct TestProps {
pub compile_flags: Vec<String>,
// Extra flags to pass when the compiled code is run (such as --bench)
pub run_flags: Vec<String>,
+ /// Extra flags to pass to rustdoc but not the compiler.
+ pub doc_flags: Vec<String>,
// If present, the name of a file that this test should match when
// pretty-printed
pub pp_exact: Option<PathBuf>,
@@ -122,6 +124,9 @@ pub struct TestProps {
pub unset_exec_env: Vec<String>,
// Build documentation for all specified aux-builds as well
pub build_aux_docs: bool,
+ /// Build the documentation for each crate in a unique output directory.
+ /// Uses <root output directory>/docs/<test name>/doc
+ pub unique_doc_out_dir: bool,
// Flag to force a crate to be built with the host architecture
pub force_host: bool,
// Check stdout for error-pattern output as well as stderr
@@ -220,8 +225,10 @@ mod directives {
pub const REGEX_ERROR_PATTERN: &'static str = "regex-error-pattern";
pub const COMPILE_FLAGS: &'static str = "compile-flags";
pub const RUN_FLAGS: &'static str = "run-flags";
+ pub const DOC_FLAGS: &'static str = "doc-flags";
pub const SHOULD_ICE: &'static str = "should-ice";
pub const BUILD_AUX_DOCS: &'static str = "build-aux-docs";
+ pub const UNIQUE_DOC_OUT_DIR: &'static str = "unique-doc-out-dir";
pub const FORCE_HOST: &'static str = "force-host";
pub const CHECK_STDOUT: &'static str = "check-stdout";
pub const CHECK_RUN_RESULTS: &'static str = "check-run-results";
@@ -267,6 +274,7 @@ impl TestProps {
regex_error_patterns: vec![],
compile_flags: vec![],
run_flags: vec![],
+ doc_flags: vec![],
pp_exact: None,
aux_builds: vec![],
aux_bins: vec![],
@@ -281,6 +289,7 @@ impl TestProps {
exec_env: vec![],
unset_exec_env: vec![],
build_aux_docs: false,
+ unique_doc_out_dir: false,
force_host: false,
check_stdout: false,
check_run_results: false,
@@ -378,6 +387,8 @@ impl TestProps {
|r| r,
);
+ config.push_name_value_directive(ln, DOC_FLAGS, &mut self.doc_flags, |r| r);
+
fn split_flags(flags: &str) -> Vec<String> {
// Individual flags can be single-quoted to preserve spaces; see
// <https://github.com/rust-lang/rust/pull/115948/commits/957c5db6>.
@@ -415,6 +426,8 @@ impl TestProps {
config.set_name_directive(ln, SHOULD_ICE, &mut self.should_ice);
config.set_name_directive(ln, BUILD_AUX_DOCS, &mut self.build_aux_docs);
+ config.set_name_directive(ln, UNIQUE_DOC_OUT_DIR, &mut self.unique_doc_out_dir);
+
config.set_name_directive(ln, FORCE_HOST, &mut self.force_host);
config.set_name_directive(ln, CHECK_STDOUT, &mut self.check_stdout);
config.set_name_directive(ln, CHECK_RUN_RESULTS, &mut self.check_run_results);
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 1f15605d8beed..b1b6d6fc8eb18 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1,5 +1,6 @@
// ignore-tidy-filelength
+use std::borrow::Cow;
use std::collections::{HashMap, HashSet};
use std::ffi::{OsStr, OsString};
use std::fs::{self, create_dir_all, File, OpenOptions};
@@ -723,7 +724,7 @@ impl<'test> TestCx<'test> {
self.maybe_add_external_args(&mut rustc, &self.config.target_rustcflags);
rustc.args(&self.props.compile_flags);
- self.compose_and_run_compiler(rustc, Some(src))
+ self.compose_and_run_compiler(rustc, Some(src), self.testpaths)
}
fn run_debuginfo_test(&self) {
@@ -1579,13 +1580,15 @@ impl<'test> TestCx<'test> {
passes,
);
- self.compose_and_run_compiler(rustc, None)
+ self.compose_and_run_compiler(rustc, None, self.testpaths)
}
- fn document(&self, out_dir: &Path) -> ProcRes {
+ /// `root_out_dir` and `root_testpaths` refer to the parameters of the actual test being run.
+ /// Auxiliaries, no matter how deep, have the same root_out_dir and root_testpaths.
+ fn document(&self, root_out_dir: &Path, root_testpaths: &TestPaths) -> ProcRes {
if self.props.build_aux_docs {
for rel_ab in &self.props.aux_builds {
- let aux_testpaths = self.compute_aux_test_paths(&self.testpaths, rel_ab);
+ let aux_testpaths = self.compute_aux_test_paths(root_testpaths, rel_ab);
let aux_props =
self.props.from_aux_file(&aux_testpaths.file, self.revision, self.config);
let aux_cx = TestCx {
@@ -1596,7 +1599,9 @@ impl<'test> TestCx<'test> {
};
// Create the directory for the stdout/stderr files.
create_dir_all(aux_cx.output_base_dir()).unwrap();
- let auxres = aux_cx.document(out_dir);
+ // use root_testpaths here, because aux-builds should have the
+ // same --out-dir and auxiliary directory.
+ let auxres = aux_cx.document(&root_out_dir, root_testpaths);
if !auxres.status.success() {
return auxres;
}
@@ -1606,21 +1611,40 @@ impl<'test> TestCx<'test> {
let aux_dir = self.aux_output_dir_name();
let rustdoc_path = self.config.rustdoc_path.as_ref().expect("--rustdoc-path not passed");
- let mut rustdoc = Command::new(rustdoc_path);
+ // actual --out-dir given to the auxiliary or test, as opposed to the root out dir for the entire
+ // test
+ let out_dir: Cow<'_, Path> = if self.props.unique_doc_out_dir {
+ let file_name = self.testpaths.file.file_stem().expect("file name should not be empty");
+ let out_dir = PathBuf::from_iter([
+ root_out_dir,
+ Path::new("docs"),
+ Path::new(file_name),
+ Path::new("doc"),
+ ]);
+ create_dir_all(&out_dir).unwrap();
+ Cow::Owned(out_dir)
+ } else {
+ Cow::Borrowed(root_out_dir)
+ };
+
+ let mut rustdoc = Command::new(rustdoc_path);
+ let current_dir = output_base_dir(self.config, root_testpaths, self.safe_revision());
+ rustdoc.current_dir(current_dir);
rustdoc
.arg("-L")
.arg(self.config.run_lib_path.to_str().unwrap())
.arg("-L")
.arg(aux_dir)
.arg("-o")
- .arg(out_dir)
+ .arg(out_dir.as_ref())
.arg("--deny")
.arg("warnings")
.arg(&self.testpaths.file)
.arg("-A")
.arg("internal_features")
- .args(&self.props.compile_flags);
+ .args(&self.props.compile_flags)
+ .args(&self.props.doc_flags);
if self.config.mode == RustdocJson {
rustdoc.arg("--output-format").arg("json").arg("-Zunstable-options");
@@ -1630,7 +1654,7 @@ impl<'test> TestCx<'test> {
rustdoc.arg(format!("-Clinker={}", linker));
}
- self.compose_and_run_compiler(rustdoc, None)
+ self.compose_and_run_compiler(rustdoc, None, root_testpaths)
}
fn exec_compiled_test(&self) -> ProcRes {
@@ -1828,9 +1852,16 @@ impl<'test> TestCx<'test> {
}
}
- fn compose_and_run_compiler(&self, mut rustc: Command, input: Option<String>) -> ProcRes {
+ /// `root_testpaths` refers to the path of the original test.
+ /// the auxiliary and the test with an aux-build have the same `root_testpaths`.
+ fn compose_and_run_compiler(
+ &self,
+ mut rustc: Command,
+ input: Option<String>,
+ root_testpaths: &TestPaths,
+ ) -> ProcRes {
let aux_dir = self.aux_output_dir();
- self.build_all_auxiliary(&self.testpaths, &aux_dir, &mut rustc);
+ self.build_all_auxiliary(root_testpaths, &aux_dir, &mut rustc);
rustc.envs(self.props.rustc_env.clone());
self.props.unset_rustc_env.iter().fold(&mut rustc, Command::env_remove);
@@ -2545,7 +2576,7 @@ impl<'test> TestCx<'test> {
Vec::new(),
);
- let proc_res = self.compose_and_run_compiler(rustc, None);
+ let proc_res = self.compose_and_run_compiler(rustc, None, self.testpaths);
let output_path = self.get_filecheck_file("ll");
(proc_res, output_path)
}
@@ -2581,7 +2612,7 @@ impl<'test> TestCx<'test> {
Vec::new(),
);
- let proc_res = self.compose_and_run_compiler(rustc, None);
+ let proc_res = self.compose_and_run_compiler(rustc, None, self.testpaths);
let output_path = self.get_filecheck_file("s");
(proc_res, output_path)
}
@@ -2664,7 +2695,7 @@ impl<'test> TestCx<'test> {
let out_dir = self.output_base_dir();
remove_and_create_dir_all(&out_dir);
- let proc_res = self.document(&out_dir);
+ let proc_res = self.document(&out_dir, &self.testpaths);
if !proc_res.status.success() {
self.fatal_proc_rec("rustdoc failed!", &proc_res);
}
@@ -2723,7 +2754,7 @@ impl<'test> TestCx<'test> {
let aux_dir = new_rustdoc.aux_output_dir();
new_rustdoc.build_all_auxiliary(&new_rustdoc.testpaths, &aux_dir, &mut rustc);
- let proc_res = new_rustdoc.document(&compare_dir);
+ let proc_res = new_rustdoc.document(&compare_dir, &new_rustdoc.testpaths);
if !proc_res.status.success() {
eprintln!("failed to run nightly rustdoc");
return;
@@ -2847,7 +2878,7 @@ impl<'test> TestCx<'test> {
let out_dir = self.output_base_dir();
remove_and_create_dir_all(&out_dir);
- let proc_res = self.document(&out_dir);
+ let proc_res = self.document(&out_dir, &self.testpaths);
if !proc_res.status.success() {
self.fatal_proc_rec("rustdoc failed!", &proc_res);
}
@@ -2923,31 +2954,24 @@ impl<'test> TestCx<'test> {
fn check_rustdoc_test_option(&self, res: ProcRes) {
let mut other_files = Vec::new();
let mut files: HashMap<String, Vec<usize>> = HashMap::new();
- let cwd = env::current_dir().unwrap();
- files.insert(
- self.testpaths
- .file
- .strip_prefix(&cwd)
- .unwrap_or(&self.testpaths.file)
- .to_str()
- .unwrap()
- .replace('\\', "/"),
- self.get_lines(&self.testpaths.file, Some(&mut other_files)),
- );
+ let normalized = fs::canonicalize(&self.testpaths.file).expect("failed to canonicalize");
+ let normalized = normalized.to_str().unwrap().replace('\\', "/");
+ files.insert(normalized, self.get_lines(&self.testpaths.file, Some(&mut other_files)));
for other_file in other_files {
let mut path = self.testpaths.file.clone();
path.set_file_name(&format!("{}.rs", other_file));
- files.insert(
- path.strip_prefix(&cwd).unwrap_or(&path).to_str().unwrap().replace('\\', "/"),
- self.get_lines(&path, None),
- );
+ let path = fs::canonicalize(path).expect("failed to canonicalize");
+ let normalized = path.to_str().unwrap().replace('\\', "/");
+ files.insert(normalized, self.get_lines(&path, None));
}
let mut tested = 0;
for _ in res.stdout.split('\n').filter(|s| s.starts_with("test ")).inspect(|s| {
if let Some((left, right)) = s.split_once(" - ") {
let path = left.rsplit("test ").next().unwrap();
- if let Some(ref mut v) = files.get_mut(&path.replace('\\', "/")) {
+ let path = fs::canonicalize(&path).expect("failed to canonicalize");
+ let path = path.to_str().unwrap().replace('\\', "/");
+ if let Some(ref mut v) = files.get_mut(&path) {
tested += 1;
let mut iter = right.split("(line ");
iter.next();
@@ -3779,7 +3803,7 @@ impl<'test> TestCx<'test> {
if let Some(nodejs) = &self.config.nodejs {
let out_dir = self.output_base_dir();
- self.document(&out_dir);
+ self.document(&out_dir, &self.testpaths);
let root = self.config.find_rust_src_root().unwrap();
let file_stem =
@@ -4095,7 +4119,7 @@ impl<'test> TestCx<'test> {
rustc.arg(crate_name);
}
- let res = self.compose_and_run_compiler(rustc, None);
+ let res = self.compose_and_run_compiler(rustc, None, self.testpaths);
if !res.status.success() {
self.fatal_proc_rec("failed to compile fixed code", &res);
}
diff --git a/src/tools/compiletest/src/runtest/coverage.rs b/src/tools/compiletest/src/runtest/coverage.rs
index 6ee147da5a965..05191a159801c 100644
--- a/src/tools/compiletest/src/runtest/coverage.rs
+++ b/src/tools/compiletest/src/runtest/coverage.rs
@@ -191,7 +191,7 @@ impl<'test> TestCx<'test> {
rustdoc_cmd.arg(&self.testpaths.file);
- let proc_res = self.compose_and_run_compiler(rustdoc_cmd, None);
+ let proc_res = self.compose_and_run_compiler(rustdoc_cmd, None, self.testpaths);
if !proc_res.status.success() {
self.fatal_proc_rec("rustdoc --test failed!", &proc_res)
}
diff --git a/src/tools/run-make-support/src/external_deps/clang.rs b/src/tools/run-make-support/src/external_deps/clang.rs
index 2b0712541cd5f..2d110c6825e05 100644
--- a/src/tools/run-make-support/src/external_deps/clang.rs
+++ b/src/tools/run-make-support/src/external_deps/clang.rs
@@ -1,7 +1,7 @@
use std::path::Path;
use crate::command::Command;
-use crate::{bin_name, env_var};
+use crate::{bin_name, cwd, env_var};
/// Construct a new `clang` invocation. `clang` is not always available for all targets.
#[track_caller]
@@ -23,7 +23,8 @@ impl Clang {
#[track_caller]
pub fn new() -> Self {
let clang = env_var("CLANG");
- let cmd = Command::new(clang);
+ let mut cmd = Command::new(clang);
+ cmd.arg("-L").arg(cwd());
Self { cmd }
}
diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
index c06cefa91a924..dc651fdd8205a 100644
--- a/src/tools/run-make-support/src/external_deps/llvm.rs
+++ b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -151,7 +151,8 @@ impl LlvmReadobj {
self
}
- /// Pass `--symbols` to display the symbol.
+ /// Pass `--symbols` to display the symbol table, including both local
+ /// and global symbols.
pub fn symbols(&mut self) -> &mut Self {
self.cmd.arg("--symbols");
self
@@ -246,6 +247,12 @@ impl LlvmObjdump {
self.cmd.arg(path.as_ref());
self
}
+
+ /// Disassemble all executable sections found in the input files.
+ pub fn disassemble(&mut self) -> &mut Self {
+ self.cmd.arg("-d");
+ self
+ }
}
impl LlvmAr {
diff --git a/src/tools/run-make-support/src/fs.rs b/src/tools/run-make-support/src/fs.rs
index 0a79616163308..2c35ba52a629c 100644
--- a/src/tools/run-make-support/src/fs.rs
+++ b/src/tools/run-make-support/src/fs.rs
@@ -9,11 +9,19 @@ pub fn create_symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) {
if link.as_ref().exists() {
std::fs::remove_dir(link.as_ref()).unwrap();
}
- std::os::windows::fs::symlink_file(original.as_ref(), link.as_ref()).expect(&format!(
- "failed to create symlink {:?} for {:?}",
- link.as_ref().display(),
- original.as_ref().display(),
- ));
+ if original.as_ref().is_file() {
+ std::os::windows::fs::symlink_file(original.as_ref(), link.as_ref()).expect(&format!(
+ "failed to create symlink {:?} for {:?}",
+ link.as_ref().display(),
+ original.as_ref().display(),
+ ));
+ } else {
+ std::os::windows::fs::symlink_dir(original.as_ref(), link.as_ref()).expect(&format!(
+ "failed to create symlink {:?} for {:?}",
+ link.as_ref().display(),
+ original.as_ref().display(),
+ ));
+ }
}
/// Creates a new symlink to a path on the filesystem, adjusting for Windows or Unix.
@@ -41,6 +49,8 @@ pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
let ty = entry.file_type()?;
if ty.is_dir() {
copy_dir_all_inner(entry.path(), dst.join(entry.file_name()))?;
+ } else if ty.is_symlink() {
+ copy_symlink(entry.path(), dst.join(entry.file_name()))?;
} else {
std::fs::copy(entry.path(), dst.join(entry.file_name()))?;
}
@@ -59,6 +69,12 @@ pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
}
}
+fn copy_symlink<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<()> {
+ let target_path = std::fs::read_link(from).unwrap();
+ create_symlink(target_path, to);
+ Ok(())
+}
+
/// Helper for reading entries in a given directory.
pub fn read_dir_entries<P: AsRef<Path>, F: FnMut(&Path)>(dir: P, mut callback: F) {
for entry in read_dir(dir) {
diff --git a/src/tools/rustfmt/tests/source/cfg_if/detect/os/x86.rs b/src/tools/rustfmt/tests/source/cfg_if/detect/os/x86.rs
index 9257b8a4be636..b9adc67221aea 100644
--- a/src/tools/rustfmt/tests/source/cfg_if/detect/os/x86.rs
+++ b/src/tools/rustfmt/tests/source/cfg_if/detect/os/x86.rs
@@ -34,15 +34,6 @@ pub fn check_for(x: Feature) -> bool {
fn detect_features() -> cache::Initializer {
let mut value = cache::Initializer::default();
- // If the x86 CPU does not support the CPUID instruction then it is too
- // old to support any of the currently-detectable features.
- if !has_cpuid() {
- return value;
- }
-
- // Calling `__cpuid`/`__cpuid_count` from here on is safe because the CPU
- // has `cpuid` support.
-
// 0. EAX = 0: Basic Information:
// - EAX returns the "Highest Function Parameter", that is, the maximum
// leaf value for subsequent calls of `cpuinfo` in range [0,
diff --git a/src/tools/rustfmt/tests/target/cfg_if/detect/os/x86.rs b/src/tools/rustfmt/tests/target/cfg_if/detect/os/x86.rs
index 2e228aa374527..944b51615f8e5 100644
--- a/src/tools/rustfmt/tests/target/cfg_if/detect/os/x86.rs
+++ b/src/tools/rustfmt/tests/target/cfg_if/detect/os/x86.rs
@@ -34,15 +34,6 @@ pub fn check_for(x: Feature) -> bool {
fn detect_features() -> cache::Initializer {
let mut value = cache::Initializer::default();
- // If the x86 CPU does not support the CPUID instruction then it is too
- // old to support any of the currently-detectable features.
- if !has_cpuid() {
- return value;
- }
-
- // Calling `__cpuid`/`__cpuid_count` from here on is safe because the CPU
- // has `cpuid` support.
-
// 0. EAX = 0: Basic Information:
// - EAX returns the "Highest Function Parameter", that is, the maximum
// leaf value for subsequent calls of `cpuinfo` in range [0,
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 2561df2e4772e..3b131cebae327 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -1,8 +1,6 @@
run-make/branch-protection-check-IBT/Makefile
run-make/cat-and-grep-sanity-check/Makefile
run-make/cdylib-dylib-linkage/Makefile
-run-make/cross-lang-lto-clang/Makefile
-run-make/cross-lang-lto-pgo-smoketest/Makefile
run-make/cross-lang-lto-upstream-rlibs/Makefile
run-make/dep-info-doesnt-run-much/Makefile
run-make/dep-info-spaces/Makefile
@@ -27,16 +25,11 @@ run-make/pgo-gen-lto/Makefile
run-make/pgo-indirect-call-promotion/Makefile
run-make/print-calling-conventions/Makefile
run-make/print-target-list/Makefile
-run-make/raw-dylib-alt-calling-convention/Makefile
-run-make/raw-dylib-c/Makefile
-run-make/redundant-libs/Makefile
run-make/remap-path-prefix-dwarf/Makefile
-run-make/reproducible-build-2/Makefile
run-make/reproducible-build/Makefile
run-make/rlib-format-packed-bundled-libs/Makefile
run-make/simd-ffi/Makefile
run-make/split-debuginfo/Makefile
-run-make/stable-symbol-names/Makefile
run-make/staticlib-dylib-linkage/Makefile
run-make/symbol-mangling-hashed/Makefile
run-make/sysroot-crates-are-unstable/Makefile
diff --git a/tests/codegen-units/item-collection/generic-impl.rs b/tests/codegen-units/item-collection/generic-impl.rs
index b4cd99272b152..23d09e0d8af3e 100644
--- a/tests/codegen-units/item-collection/generic-impl.rs
+++ b/tests/codegen-units/item-collection/generic-impl.rs
@@ -22,16 +22,16 @@ impl<T> Struct<T> {
}
}
-pub struct _LifeTimeOnly<'a> {
+pub struct LifeTimeOnly<'a> {
_a: &'a u32,
}
-impl<'a> _LifeTimeOnly<'a> {
- //~ MONO_ITEM fn _LifeTimeOnly::<'_>::foo
+impl<'a> LifeTimeOnly<'a> {
+ //~ MONO_ITEM fn LifeTimeOnly::<'_>::foo
pub fn foo(&self) {}
- //~ MONO_ITEM fn _LifeTimeOnly::<'_>::bar
+ //~ MONO_ITEM fn LifeTimeOnly::<'_>::bar
pub fn bar(&'a self) {}
- //~ MONO_ITEM fn _LifeTimeOnly::<'_>::baz
+ //~ MONO_ITEM fn LifeTimeOnly::<'_>::baz
pub fn baz<'b>(&'b self) {}
pub fn non_instantiated<T>(&self) {}
diff --git a/tests/codegen-units/item-collection/overloaded-operators.rs b/tests/codegen-units/item-collection/overloaded-operators.rs
index e00e22dbab996..69b55695d3d30 100644
--- a/tests/codegen-units/item-collection/overloaded-operators.rs
+++ b/tests/codegen-units/item-collection/overloaded-operators.rs
@@ -5,44 +5,44 @@
use std::ops::{Add, Deref, Index, IndexMut};
-pub struct _Indexable {
+pub struct Indexable {
data: [u8; 3],
}
-impl Index<usize> for _Indexable {
+impl Index<usize> for Indexable {
type Output = u8;
- //~ MONO_ITEM fn <_Indexable as std::ops::Index<usize>>::index
+ //~ MONO_ITEM fn <Indexable as std::ops::Index<usize>>::index
fn index(&self, index: usize) -> &Self::Output {
if index >= 3 { &self.data[0] } else { &self.data[index] }
}
}
-impl IndexMut<usize> for _Indexable {
- //~ MONO_ITEM fn <_Indexable as std::ops::IndexMut<usize>>::index_mut
+impl IndexMut<usize> for Indexable {
+ //~ MONO_ITEM fn <Indexable as std::ops::IndexMut<usize>>::index_mut
fn index_mut(&mut self, index: usize) -> &mut Self::Output {
if index >= 3 { &mut self.data[0] } else { &mut self.data[index] }
}
}
-//~ MONO_ITEM fn <_Equatable as std::cmp::PartialEq>::eq
-//~ MONO_ITEM fn <_Equatable as std::cmp::PartialEq>::ne
+//~ MONO_ITEM fn <Equatable as std::cmp::PartialEq>::eq
+//~ MONO_ITEM fn <Equatable as std::cmp::PartialEq>::ne
#[derive(PartialEq)]
-pub struct _Equatable(u32);
+pub struct Equatable(u32);
-impl Add<u32> for _Equatable {
+impl Add<u32> for Equatable {
type Output = u32;
- //~ MONO_ITEM fn <_Equatable as std::ops::Add<u32>>::add
+ //~ MONO_ITEM fn <Equatable as std::ops::Add<u32>>::add
fn add(self, rhs: u32) -> u32 {
self.0 + rhs
}
}
-impl Deref for _Equatable {
+impl Deref for Equatable {
type Target = u32;
- //~ MONO_ITEM fn <_Equatable as std::ops::Deref>::deref
+ //~ MONO_ITEM fn <Equatable as std::ops::Deref>::deref
fn deref(&self) -> &Self::Target {
&self.0
}
diff --git a/tests/run-make/cross-lang-lto-clang/Makefile b/tests/run-make/cross-lang-lto-clang/Makefile
deleted file mode 100644
index acf49c8f5c85d..0000000000000
--- a/tests/run-make/cross-lang-lto-clang/Makefile
+++ /dev/null
@@ -1,25 +0,0 @@
-# needs-force-clang-based-tests
-
-# This test makes sure that cross-language inlining actually works by checking
-# the generated machine code.
-
-include ../tools.mk
-
-all: cpp-executable rust-executable
-
-cpp-executable:
- $(RUSTC) -Clinker-plugin-lto=on -o $(TMPDIR)/librustlib-xlto.a -Copt-level=2 -Ccodegen-units=1 ./rustlib.rs
- $(CLANG) -flto=thin -fuse-ld=lld -L $(TMPDIR) -lrustlib-xlto -o $(TMPDIR)/cmain ./cmain.c -O3
- # Make sure we don't find a call instruction to the function we expect to
- # always be inlined.
- "$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/cmain | $(CGREP) -v -e "call.*rust_always_inlined"
- # As a sanity check, make sure we do find a call instruction to a
- # non-inlined function
- "$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/cmain | $(CGREP) -e "call.*rust_never_inlined"
-
-rust-executable:
- $(CLANG) ./clib.c -flto=thin -c -o $(TMPDIR)/clib.o -O2
- (cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
- $(RUSTC) -Clinker-plugin-lto=on -L$(TMPDIR) -Copt-level=2 -Clinker=$(CLANG) -Clink-arg=-fuse-ld=lld ./main.rs -o $(TMPDIR)/rsmain
- "$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/rsmain | $(CGREP) -e "call.*c_never_inlined"
- "$(LLVM_BIN_DIR)"/llvm-objdump -d $(TMPDIR)/rsmain | $(CGREP) -v -e "call.*c_always_inlined"
diff --git a/tests/run-make/cross-lang-lto-clang/rmake.rs b/tests/run-make/cross-lang-lto-clang/rmake.rs
new file mode 100644
index 0000000000000..1b15a54aacb02
--- /dev/null
+++ b/tests/run-make/cross-lang-lto-clang/rmake.rs
@@ -0,0 +1,62 @@
+// This test checks that cross-language inlining actually works by checking
+// the generated machine code.
+// See https://github.com/rust-lang/rust/pull/57514
+
+//@ needs-force-clang-based-tests
+// NOTE(#126180): This test only runs on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+
+use run_make_support::{clang, env_var, llvm_ar, llvm_objdump, rustc, static_lib_name};
+
+fn main() {
+ rustc()
+ .linker_plugin_lto("on")
+ .output(static_lib_name("rustlib-xlto"))
+ .opt_level("2")
+ .codegen_units(1)
+ .input("rustlib.rs")
+ .run();
+ clang()
+ .lto("thin")
+ .use_ld("lld")
+ .arg("-lrustlib-xlto")
+ .out_exe("cmain")
+ .input("cmain.c")
+ .arg("-O3")
+ .run();
+ // Make sure we don't find a call instruction to the function we expect to
+ // always be inlined.
+ llvm_objdump()
+ .disassemble()
+ .input("cmain")
+ .run()
+ .assert_stdout_not_contains_regex("call.*rust_always_inlined");
+ // As a sanity check, make sure we do find a call instruction to a
+ // non-inlined function
+ llvm_objdump()
+ .disassemble()
+ .input("cmain")
+ .run()
+ .assert_stdout_contains_regex("call.*rust_never_inlined");
+ clang().input("clib.c").lto("thin").arg("-c").out_exe("clib.o").arg("-O2").run();
+ llvm_ar().obj_to_ar().output_input(static_lib_name("xyz"), "clib.o").run();
+ rustc()
+ .linker_plugin_lto("on")
+ .opt_level("2")
+ .linker(&env_var("CLANG"))
+ .link_arg("-fuse-ld=lld")
+ .input("main.rs")
+ .output("rsmain")
+ .run();
+ llvm_objdump()
+ .disassemble()
+ .input("rsmain")
+ .run()
+ .assert_stdout_not_contains_regex("call.*c_always_inlined");
+ llvm_objdump()
+ .disassemble()
+ .input("rsmain")
+ .run()
+ .assert_stdout_contains_regex("call.*c_never_inlined");
+}
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest/clib.c b/tests/run-make/cross-lang-lto-pgo-smoketest-clang/clib.c
similarity index 100%
rename from tests/run-make/cross-lang-lto-pgo-smoketest/clib.c
rename to tests/run-make/cross-lang-lto-pgo-smoketest-clang/clib.c
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest/cmain.c b/tests/run-make/cross-lang-lto-pgo-smoketest-clang/cmain.c
similarity index 100%
rename from tests/run-make/cross-lang-lto-pgo-smoketest/cmain.c
rename to tests/run-make/cross-lang-lto-pgo-smoketest-clang/cmain.c
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest/main.rs b/tests/run-make/cross-lang-lto-pgo-smoketest-clang/main.rs
similarity index 100%
rename from tests/run-make/cross-lang-lto-pgo-smoketest/main.rs
rename to tests/run-make/cross-lang-lto-pgo-smoketest-clang/main.rs
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest-clang/rmake.rs b/tests/run-make/cross-lang-lto-pgo-smoketest-clang/rmake.rs
new file mode 100644
index 0000000000000..03c9af4bb8982
--- /dev/null
+++ b/tests/run-make/cross-lang-lto-pgo-smoketest-clang/rmake.rs
@@ -0,0 +1,120 @@
+// This test makes sure that cross-language inlining can be used in conjunction
+// with profile-guided optimization. The test only tests that the whole workflow
+// can be executed without anything crashing. It does not test whether PGO or
+// xLTO have any specific effect on the generated code.
+// See https://github.com/rust-lang/rust/pull/61036
+
+//@ needs-force-clang-based-tests
+// NOTE(#126180): This test would only run on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+
+//@ needs-profiler-support
+// FIXME(Oneirical): Except that due to the reliance on llvm-profdata, this test
+// never runs, because `x86_64-gnu-debug` does not have the `profiler_builtins` crate.
+
+//FIXME(Oneirical): There was a strange workaround for MSVC on this test
+// which added -C panic=abort to every RUSTC call. It was justified as follows:
+
+// "LLVM doesn't support instrumenting binaries that use SEH:
+// https://bugs.llvm.org/show_bug.cgi?id=41279
+// Things work fine with -Cpanic=abort though."
+
+// This isn't very pertinent, however, as the test does not get run on any
+// MSVC platforms.
+
+use run_make_support::{
+ clang, env_var, has_extension, has_prefix, llvm_ar, llvm_profdata, rfs, run, rustc,
+ shallow_find_files, static_lib_name,
+};
+
+fn main() {
+ rustc()
+ .linker_plugin_lto("on")
+ .output(static_lib_name("rustlib-xlto"))
+ .opt_level("3")
+ .codegen_units(1)
+ .input("rustlib.rs")
+ .arg("-Cprofile-generate=cpp-profdata")
+ .run();
+ clang()
+ .lto("thin")
+ .arg("-fprofile-generate=cpp-profdata")
+ .use_ld("lld")
+ .arg("-lrustlib-xlto")
+ .out_exe("cmain")
+ .input("cmain.c")
+ .arg("-O3")
+ .run();
+ run("cmain");
+ // Postprocess the profiling data so it can be used by the compiler
+ let profraw_files = shallow_find_files("cpp-profdata", |path| {
+ has_prefix(path, "default") && has_extension(path, "profraw")
+ });
+ let profraw_file = profraw_files.get(0).unwrap();
+ llvm_profdata().merge().output("cpp-profdata/merged.profdata").input(profraw_file).run();
+ rustc()
+ .linker_plugin_lto("on")
+ .profile_use("cpp-profdata/merged.profdata")
+ .output(static_lib_name("rustlib-xlto"))
+ .opt_level("3")
+ .codegen_units(1)
+ .input("rustlib.rs")
+ .run();
+ clang()
+ .lto("thin")
+ .arg("-fprofile-use=cpp-profdata/merged.profdata")
+ .use_ld("lld")
+ .arg("-lrustlib-xlto")
+ .out_exe("cmain")
+ .input("cmain.c")
+ .arg("-O3")
+ .run();
+
+ clang()
+ .input("clib.c")
+ .arg("-fprofile-generate=rs-profdata")
+ .lto("thin")
+ .arg("-c")
+ .out_exe("clib.o")
+ .arg("-O3")
+ .run();
+ llvm_ar().obj_to_ar().output_input(static_lib_name("xyz"), "clib.o").run();
+ rustc()
+ .linker_plugin_lto("on")
+ .opt_level("3")
+ .codegen_units(1)
+ .arg("-Cprofile-generate=rs-profdata")
+ .linker(&env_var("CLANG"))
+ .link_arg("-fuse-ld=lld")
+ .input("main.rs")
+ .output("rsmain")
+ .run();
+ run("rsmain");
+ // Postprocess the profiling data so it can be used by the compiler
+ let profraw_files = shallow_find_files("rs-profdata", |path| {
+ has_prefix(path, "default") && has_extension(path, "profraw")
+ });
+ let profraw_file = profraw_files.get(0).unwrap();
+ llvm_profdata().merge().output("rs-profdata/merged.profdata").input(profraw_file).run();
+ clang()
+ .input("clib.c")
+ .arg("-fprofile-use=rs-profdata/merged.profdata")
+ .arg("-c")
+ .lto("thin")
+ .out_exe("clib.o")
+ .arg("-O3")
+ .run();
+ rfs::remove_file(static_lib_name("xyz"));
+ llvm_ar().obj_to_ar().output_input(static_lib_name("xyz"), "clib.o").run();
+ rustc()
+ .linker_plugin_lto("on")
+ .opt_level("3")
+ .codegen_units(1)
+ .arg("-Cprofile-use=rs-profdata/merged.profdata")
+ .linker(&env_var("CLANG"))
+ .link_arg("-fuse-ld=lld")
+ .input("main.rs")
+ .output("rsmain")
+ .run();
+}
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest/rustlib.rs b/tests/run-make/cross-lang-lto-pgo-smoketest-clang/rustlib.rs
similarity index 100%
rename from tests/run-make/cross-lang-lto-pgo-smoketest/rustlib.rs
rename to tests/run-make/cross-lang-lto-pgo-smoketest-clang/rustlib.rs
diff --git a/tests/run-make/cross-lang-lto-pgo-smoketest/Makefile b/tests/run-make/cross-lang-lto-pgo-smoketest/Makefile
deleted file mode 100644
index 738e23f9c6614..0000000000000
--- a/tests/run-make/cross-lang-lto-pgo-smoketest/Makefile
+++ /dev/null
@@ -1,90 +0,0 @@
-# needs-force-clang-based-tests
-
-# FIXME(#126180): This test doesn't actually run anywhere, because the only
-# CI job that sets RUSTBUILD_FORCE_CLANG_BASED_TESTS runs very few tests.
-
-# This test makes sure that cross-language inlining can be used in conjunction
-# with profile-guided optimization. The test only tests that the whole workflow
-# can be executed without anything crashing. It does not test whether PGO or
-# xLTO have any specific effect on the generated code.
-
-include ../tools.mk
-
-COMMON_FLAGS=-Copt-level=3 -Ccodegen-units=1
-
-# LLVM doesn't support instrumenting binaries that use SEH:
-# https://bugs.llvm.org/show_bug.cgi?id=41279
-#
-# Things work fine with -Cpanic=abort though.
-ifdef IS_MSVC
-COMMON_FLAGS+= -Cpanic=abort
-endif
-
-all: cpp-executable rust-executable
-
-cpp-executable:
- $(RUSTC) -Clinker-plugin-lto=on \
- -Cprofile-generate="$(TMPDIR)"/cpp-profdata \
- -o "$(TMPDIR)"/librustlib-xlto.a \
- $(COMMON_FLAGS) \
- ./rustlib.rs
- $(CLANG) -flto=thin \
- -fprofile-generate="$(TMPDIR)"/cpp-profdata \
- -fuse-ld=lld \
- -L "$(TMPDIR)" \
- -lrustlib-xlto \
- -o "$(TMPDIR)"/cmain \
- -O3 \
- ./cmain.c
- $(TMPDIR)/cmain
- # Postprocess the profiling data so it can be used by the compiler
- "$(LLVM_BIN_DIR)"/llvm-profdata merge \
- -o "$(TMPDIR)"/cpp-profdata/merged.profdata \
- "$(TMPDIR)"/cpp-profdata/default_*.profraw
- $(RUSTC) -Clinker-plugin-lto=on \
- -Cprofile-use="$(TMPDIR)"/cpp-profdata/merged.profdata \
- -o "$(TMPDIR)"/librustlib-xlto.a \
- $(COMMON_FLAGS) \
- ./rustlib.rs
- $(CLANG) -flto=thin \
- -fprofile-use="$(TMPDIR)"/cpp-profdata/merged.profdata \
- -fuse-ld=lld \
- -L "$(TMPDIR)" \
- -lrustlib-xlto \
- -o "$(TMPDIR)"/cmain \
- -O3 \
- ./cmain.c
-
-rust-executable:
- exit
- $(CLANG) ./clib.c -fprofile-generate="$(TMPDIR)"/rs-profdata -flto=thin -c -o $(TMPDIR)/clib.o -O3
- (cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
- $(RUSTC) -Clinker-plugin-lto=on \
- -Cprofile-generate="$(TMPDIR)"/rs-profdata \
- -L$(TMPDIR) \
- $(COMMON_FLAGS) \
- -Clinker=$(CLANG) \
- -Clink-arg=-fuse-ld=lld \
- -o $(TMPDIR)/rsmain \
- ./main.rs
- $(TMPDIR)/rsmain
- # Postprocess the profiling data so it can be used by the compiler
- "$(LLVM_BIN_DIR)"/llvm-profdata merge \
- -o "$(TMPDIR)"/rs-profdata/merged.profdata \
- "$(TMPDIR)"/rs-profdata/default_*.profraw
- $(CLANG) ./clib.c \
- -fprofile-use="$(TMPDIR)"/rs-profdata/merged.profdata \
- -flto=thin \
- -c \
- -o $(TMPDIR)/clib.o \
- -O3
- rm "$(TMPDIR)"/libxyz.a
- (cd $(TMPDIR); $(AR) crus ./libxyz.a ./clib.o)
- $(RUSTC) -Clinker-plugin-lto=on \
- -Cprofile-use="$(TMPDIR)"/rs-profdata/merged.profdata \
- -L$(TMPDIR) \
- $(COMMON_FLAGS) \
- -Clinker=$(CLANG) \
- -Clink-arg=-fuse-ld=lld \
- -o $(TMPDIR)/rsmain \
- ./main.rs
diff --git a/tests/run-make/cross-lang-lto-riscv-abi/rmake.rs b/tests/run-make/cross-lang-lto-riscv-abi/rmake.rs
index 391759ec5f662..92573353a741b 100644
--- a/tests/run-make/cross-lang-lto-riscv-abi/rmake.rs
+++ b/tests/run-make/cross-lang-lto-riscv-abi/rmake.rs
@@ -3,8 +3,11 @@
//@ needs-force-clang-based-tests
//@ needs-llvm-components riscv
-// FIXME(#126180): This test doesn't actually run anywhere, because the only
-// CI job that sets RUSTBUILD_FORCE_CLANG_BASED_TESTS runs very few tests.
+//@ needs-force-clang-based-tests
+// FIXME(#126180): This test can only run on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+// However, this test does not run at all as its name does not contain "clang".
use std::path::PathBuf;
use std::process::{Command, Output};
diff --git a/tests/run-make/raw-dylib-alt-calling-convention/Makefile b/tests/run-make/raw-dylib-alt-calling-convention/Makefile
deleted file mode 100644
index 14d23a5d20106..0000000000000
--- a/tests/run-make/raw-dylib-alt-calling-convention/Makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-# Test the behavior of #[link(.., kind = "raw-dylib")] with alternative calling conventions.
-
-# only-x86
-# only-windows
-
-include ../tools.mk
-
-all:
- $(RUSTC) --crate-type lib --crate-name raw_dylib_alt_calling_convention_test lib.rs
- $(RUSTC) --crate-type bin driver.rs -L "$(TMPDIR)"
- $(call COMPILE_OBJ,"$(TMPDIR)"/extern.obj,extern.c)
-ifdef IS_MSVC
- $(CC) "$(TMPDIR)"/extern.obj -link -dll -out:"$(TMPDIR)"/extern.dll -noimplib
-else
- $(CC) "$(TMPDIR)"/extern.obj -shared -o "$(TMPDIR)"/extern.dll
-endif
-
- "$(TMPDIR)"/driver > "$(TMPDIR)"/output.txt
- $(RUSTC_TEST_OP) "$(TMPDIR)"/output.txt output.txt
-
-ifdef IS_MSVC
- "$(TMPDIR)"/driver true > "$(TMPDIR)"/output.msvc.txt
- $(RUSTC_TEST_OP) "$(TMPDIR)"/output.msvc.txt output.msvc.txt
-endif
diff --git a/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs b/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs
new file mode 100644
index 0000000000000..736b3fee2aef9
--- /dev/null
+++ b/tests/run-make/raw-dylib-alt-calling-convention/rmake.rs
@@ -0,0 +1,28 @@
+// `raw-dylib` is a Windows-specific attribute which emits idata sections for the items in the
+// attached extern block,
+// so they may be linked against without linking against an import library.
+// To learn more, read https://github.com/rust-lang/rfcs/blob/master/text/2627-raw-dylib-kind.md
+// This test uses this feature alongside alternative calling conventions, checking that both
+// features are compatible and result in the expected output upon execution of the binary.
+// See https://github.com/rust-lang/rust/pull/84171
+
+//@ only-x86
+//@ only-windows
+
+use run_make_support::{build_native_dynamic_lib, diff, is_msvc, run, run_with_args, rustc};
+
+fn main() {
+ rustc()
+ .crate_type("lib")
+ .crate_name("raw_dylib_alt_calling_convention_test")
+ .input("lib.rs")
+ .run();
+ rustc().crate_type("bin").input("driver.rs").run();
+ build_native_dynamic_lib("extern");
+ let out = run("driver").stdout_utf8();
+ diff().expected_file("output.txt").actual_text("actual", out).run();
+ if is_msvc() {
+ let out_msvc = run_with_args("driver", &["true"]).stdout_utf8();
+ diff().expected_file("output.msvc.txt").actual_text("actual", out_msvc).run();
+ }
+}
diff --git a/tests/run-make/raw-dylib-c/Makefile b/tests/run-make/raw-dylib-c/Makefile
deleted file mode 100644
index af5c4a6edd7ba..0000000000000
--- a/tests/run-make/raw-dylib-c/Makefile
+++ /dev/null
@@ -1,28 +0,0 @@
-# Test the behavior of #[link(.., kind = "raw-dylib")] on windows-msvc
-
-# only-windows
-
-include ../tools.mk
-
-all:
- $(RUSTC) --crate-type lib --crate-name raw_dylib_test lib.rs
- $(RUSTC) --crate-type bin driver.rs -L "$(TMPDIR)"
- $(RUSTC) --crate-type bin --crate-name raw_dylib_test_bin lib.rs
- $(call COMPILE_OBJ,"$(TMPDIR)"/extern_1.obj,extern_1.c)
- $(call COMPILE_OBJ,"$(TMPDIR)"/extern_2.obj,extern_2.c)
-ifdef IS_MSVC
- $(CC) "$(TMPDIR)"/extern_1.obj -link -dll -out:"$(TMPDIR)"/extern_1.dll -noimplib
- $(CC) "$(TMPDIR)"/extern_2.obj -link -dll -out:"$(TMPDIR)"/extern_2.dll -noimplib
-else
- $(CC) "$(TMPDIR)"/extern_1.obj -shared -o "$(TMPDIR)"/extern_1.dll
- $(CC) "$(TMPDIR)"/extern_2.obj -shared -o "$(TMPDIR)"/extern_2.dll
-endif
- "$(TMPDIR)"/driver | tr -d '\r' > "$(TMPDIR)"/output.txt
- "$(TMPDIR)"/raw_dylib_test_bin > "$(TMPDIR)"/output_bin.txt
-
-ifdef RUSTC_BLESS_TEST
- cp "$(TMPDIR)"/output.txt output.txt
-else
- $(DIFF) output.txt "$(TMPDIR)"/output.txt
- $(DIFF) output.txt "$(TMPDIR)"/output_bin.txt
-endif
diff --git a/tests/run-make/raw-dylib-c/rmake.rs b/tests/run-make/raw-dylib-c/rmake.rs
new file mode 100644
index 0000000000000..3cfd8cb400bbf
--- /dev/null
+++ b/tests/run-make/raw-dylib-c/rmake.rs
@@ -0,0 +1,29 @@
+// `raw-dylib` is a Windows-specific attribute which emits idata sections for the items in the
+// attached extern block,
+// so they may be linked against without linking against an import library.
+// To learn more, read https://github.com/rust-lang/rfcs/blob/master/text/2627-raw-dylib-kind.md
+// This test is the simplest of the raw-dylib tests, simply smoke-testing that the feature
+// can be used to build an executable binary with an expected output with native C files
+// compiling into dynamic libraries.
+// See https://github.com/rust-lang/rust/pull/86419
+
+//@ only-windows
+
+use run_make_support::{build_native_dynamic_lib, diff, run, rustc};
+
+fn main() {
+ rustc().crate_type("lib").crate_name("raw_dylib_test").input("lib.rs").run();
+ rustc().crate_type("bin").input("driver.rs").run();
+ rustc().crate_type("bin").crate_name("raw_dylib_test_bin").input("lib.rs").run();
+ build_native_dynamic_lib("extern_1");
+ build_native_dynamic_lib("extern_2");
+ let out_driver = run("driver").stdout_utf8();
+ let out_raw = run("raw_dylib_test_bin").stdout_utf8();
+
+ diff()
+ .expected_file("output.txt")
+ .actual_text("actual", out_driver)
+ .normalize(r#"\r"#, "")
+ .run();
+ diff().expected_file("output.txt").actual_text("actual", out_raw).normalize(r#"\r"#, "").run();
+}
diff --git a/tests/run-make/redundant-libs/Makefile b/tests/run-make/redundant-libs/Makefile
deleted file mode 100644
index 0a48b2b280136..0000000000000
--- a/tests/run-make/redundant-libs/Makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# ignore-windows-msvc
-
-# rustc will remove one of the two redundant references to foo below. Depending
-# on which one gets removed, we'll get a linker error on SOME platforms (like
-# Linux). On these platforms, when a library is referenced, the linker will
-# only pull in the symbols needed _at that point in time_. If a later library
-# depends on additional symbols from the library, they will not have been pulled
-# in, and you'll get undefined symbols errors.
-#
-# So in this example, we need to ensure that rustc keeps the _later_ reference
-# to foo, and not the former one.
-RUSTC_FLAGS = \
- -l static=bar \
- -l foo \
- -l static=baz \
- -l foo \
- --print link-args
-
-all: $(call DYLIB,foo) $(call STATICLIB,bar) $(call STATICLIB,baz)
- $(RUSTC) $(RUSTC_FLAGS) main.rs
- $(call RUN,main)
diff --git a/tests/run-make/redundant-libs/rmake.rs b/tests/run-make/redundant-libs/rmake.rs
new file mode 100644
index 0000000000000..fb1b3bca8ade3
--- /dev/null
+++ b/tests/run-make/redundant-libs/rmake.rs
@@ -0,0 +1,34 @@
+// rustc will remove one of the two redundant references to foo below. Depending
+// on which one gets removed, we'll get a linker error on SOME platforms (like
+// Linux). On these platforms, when a library is referenced, the linker will
+// only pull in the symbols needed _at that point in time_. If a later library
+// depends on additional symbols from the library, they will not have been pulled
+// in, and you'll get undefined symbols errors.
+//
+// So in this example, we need to ensure that rustc keeps the _later_ reference
+// to foo, and not the former one.
+
+//@ ignore-cross-compile
+// Reason: the compiled binary is executed
+//@ ignore-windows-msvc
+// Reason: this test links libraries via link.exe, which only accepts the import library
+// for the dynamic library, i.e. `foo.dll.lib`. However, build_native_dynamic_lib only
+// produces `foo.dll` - the dynamic library itself. To make this test work on MSVC, one
+// would need to derive the import library from the dynamic library.
+// See https://stackoverflow.com/questions/9360280/
+
+use run_make_support::{
+ build_native_dynamic_lib, build_native_static_lib, cwd, is_msvc, rfs, run, rustc,
+};
+
+fn main() {
+ build_native_dynamic_lib("foo");
+ build_native_static_lib("bar");
+ build_native_static_lib("baz");
+ rustc()
+ .args(&["-lstatic=bar", "-lfoo", "-lstatic=baz", "-lfoo"])
+ .input("main.rs")
+ .print("link-args")
+ .run();
+ run("main");
+}
diff --git a/tests/run-make/reproducible-build-2/Makefile b/tests/run-make/reproducible-build-2/Makefile
deleted file mode 100644
index 68fcac8b47f5f..0000000000000
--- a/tests/run-make/reproducible-build-2/Makefile
+++ /dev/null
@@ -1,27 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# ignore-musl
-# ignore-windows
-# Objects are reproducible but their path is not.
-
-all: \
- fat_lto \
- sysroot
-
-fat_lto:
- rm -rf $(TMPDIR) && mkdir $(TMPDIR)
- $(RUSTC) reproducible-build-aux.rs
- $(RUSTC) reproducible-build.rs -C lto=fat
- cp $(TMPDIR)/reproducible-build $(TMPDIR)/reproducible-build-a
- $(RUSTC) reproducible-build.rs -C lto=fat
- cmp "$(TMPDIR)/reproducible-build-a" "$(TMPDIR)/reproducible-build" || exit 1
-
-sysroot:
- rm -rf $(TMPDIR) && mkdir $(TMPDIR)
- $(RUSTC) reproducible-build-aux.rs
- $(RUSTC) reproducible-build.rs --crate-type rlib --sysroot $(shell $(RUSTC) --print sysroot) --remap-path-prefix=$(shell $(RUSTC) --print sysroot)=/sysroot
- cp -R $(shell $(RUSTC) --print sysroot) $(TMPDIR)/sysroot
- cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfoo.rlib
- $(RUSTC) reproducible-build.rs --crate-type rlib --sysroot $(TMPDIR)/sysroot --remap-path-prefix=$(TMPDIR)/sysroot=/sysroot
- cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
diff --git a/tests/run-make/reproducible-build-2/rmake.rs b/tests/run-make/reproducible-build-2/rmake.rs
new file mode 100644
index 0000000000000..c500c4238b088
--- /dev/null
+++ b/tests/run-make/reproducible-build-2/rmake.rs
@@ -0,0 +1,47 @@
+// Builds with fat link-time-optimizations and the --sysroot flag used to be
+// non-deterministic - that means, compiling twice with no changes would create
+// slightly different outputs. This has been fixed by #63352 and #63505.
+// Test 1: Compile with fat-lto twice, check that both compilation outputs are identical.
+// Test 2: Compile with sysroot, then change the sysroot path from absolute to relative.
+// Outputs should be identical.
+// See https://github.com/rust-lang/rust/issues/34902
+
+//@ ignore-windows
+// Reasons:
+// 1. The object files are reproducible, but their paths are not, which causes
+// the first assertion in the test to fail.
+// 2. When the sysroot gets copied, some symlinks must be re-created,
+// which is a privileged action on Windows.
+
+use run_make_support::{bin_name, rfs, rust_lib_name, rustc};
+
+fn main() {
+ // test 1: fat lto
+ rustc().input("reproducible-build-aux.rs").run();
+ rustc().input("reproducible-build.rs").arg("-Clto=fat").output("reproducible-build").run();
+ rfs::rename("reproducible-build", "reproducible-build-a");
+ rustc().input("reproducible-build.rs").arg("-Clto=fat").output("reproducible-build").run();
+ assert_eq!(rfs::read("reproducible-build"), rfs::read("reproducible-build-a"));
+
+ // test 2: sysroot
+ let sysroot = rustc().print("sysroot").run().stdout_utf8();
+ let sysroot = sysroot.trim();
+
+ rustc().input("reproducible-build-aux.rs").run();
+ rustc()
+ .input("reproducible-build.rs")
+ .crate_type("rlib")
+ .sysroot(&sysroot)
+ .arg(format!("--remap-path-prefix={sysroot}=/sysroot"))
+ .run();
+ rfs::copy_dir_all(&sysroot, "sysroot");
+ rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+ rustc()
+ .input("reproducible-build.rs")
+ .crate_type("rlib")
+ .sysroot("sysroot")
+ .arg("--remap-path-prefix=/sysroot=/sysroot")
+ .run();
+
+ assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
+}
diff --git a/tests/run-make/stable-symbol-names/Makefile b/tests/run-make/stable-symbol-names/Makefile
deleted file mode 100644
index bbfb8e3888171..0000000000000
--- a/tests/run-make/stable-symbol-names/Makefile
+++ /dev/null
@@ -1,41 +0,0 @@
-include ../tools.mk
-
-# The following command will:
-# 1. dump the symbols of a library using `nm`
-# 2. extract only those lines that we are interested in via `grep`
-# 3. from those lines, extract just the symbol name via `sed`, which:
-# * always starts with "_ZN" and ends with "E" (`legacy` mangling)
-# * always starts with "_R" (`v0` mangling)
-# 4. sort those symbol names for deterministic comparison
-# 5. write the result into a file
-
-dump-symbols = nm "$(TMPDIR)/lib$(1).rlib" \
- | grep -E "$(2)" \
- | sed -E "s/.*(_ZN.*E|_R[a-zA-Z0-9_]*).*/\1/" \
- | sort \
- > "$(TMPDIR)/$(1)$(3).nm"
-
-# This test
-# - compiles each of the two crates 2 times and makes sure each time we get
-# exactly the same symbol names
-# - makes sure that both crates agree on the same symbol names for monomorphic
-# functions
-
-all:
- $(RUSTC) stable-symbol-names1.rs
- $(call dump-symbols,stable_symbol_names1,generic_|mono_,_v1)
- rm $(TMPDIR)/libstable_symbol_names1.rlib
- $(RUSTC) stable-symbol-names1.rs
- $(call dump-symbols,stable_symbol_names1,generic_|mono_,_v2)
- cmp "$(TMPDIR)/stable_symbol_names1_v1.nm" "$(TMPDIR)/stable_symbol_names1_v2.nm"
-
- $(RUSTC) stable-symbol-names2.rs
- $(call dump-symbols,stable_symbol_names2,generic_|mono_,_v1)
- rm $(TMPDIR)/libstable_symbol_names2.rlib
- $(RUSTC) stable-symbol-names2.rs
- $(call dump-symbols,stable_symbol_names2,generic_|mono_,_v2)
- cmp "$(TMPDIR)/stable_symbol_names2_v1.nm" "$(TMPDIR)/stable_symbol_names2_v2.nm"
-
- $(call dump-symbols,stable_symbol_names1,mono_,_cross)
- $(call dump-symbols,stable_symbol_names2,mono_,_cross)
- cmp "$(TMPDIR)/stable_symbol_names1_cross.nm" "$(TMPDIR)/stable_symbol_names2_cross.nm"
diff --git a/tests/run-make/stable-symbol-names/rmake.rs b/tests/run-make/stable-symbol-names/rmake.rs
new file mode 100644
index 0000000000000..402f411c7f5e6
--- /dev/null
+++ b/tests/run-make/stable-symbol-names/rmake.rs
@@ -0,0 +1,68 @@
+// A typo in rustc caused generic symbol names to be non-deterministic -
+// that is, it was possible to compile the same file twice with no changes
+// and get outputs with different symbol names.
+// This test compiles each of the two crates twice, and checks that each output
+// contains exactly the same symbol names.
+// Additionally, both crates should agree on the same symbol names for monomorphic
+// functions.
+// See https://github.com/rust-lang/rust/issues/32554
+
+use std::collections::HashSet;
+
+use run_make_support::{llvm_readobj, regex, rfs, rust_lib_name, rustc};
+
+static LEGACY_PATTERN: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
+static V0_PATTERN: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
+
+fn main() {
+ LEGACY_PATTERN.set(regex::Regex::new(r"_ZN.*E").unwrap()).unwrap();
+ V0_PATTERN.set(regex::Regex::new(r"_R[a-zA-Z0-9_]*").unwrap()).unwrap();
+ // test 1: first file
+ rustc().input("stable-symbol-names1.rs").run();
+ let sym1 = process_symbols("stable_symbol_names1", "generic_|mono_");
+ rfs::remove_file(rust_lib_name("stable_symbol_names1"));
+ rustc().input("stable-symbol-names1.rs").run();
+ let sym2 = process_symbols("stable_symbol_names1", "generic_|mono_");
+ assert_eq!(sym1, sym2);
+
+ // test 2: second file
+ rustc().input("stable-symbol-names2.rs").run();
+ let sym1 = process_symbols("stable_symbol_names2", "generic_|mono_");
+ rfs::remove_file(rust_lib_name("stable_symbol_names2"));
+ rustc().input("stable-symbol-names2.rs").run();
+ let sym2 = process_symbols("stable_symbol_names2", "generic_|mono_");
+ assert_eq!(sym1, sym2);
+
+ // test 3: crossed files
+ let sym1 = process_symbols("stable_symbol_names1", "mono_");
+ let sym2 = process_symbols("stable_symbol_names2", "mono_");
+ assert_eq!(sym1, sym2);
+}
+
+#[track_caller]
+fn process_symbols(path: &str, symbol: &str) -> Vec<String> {
+ // Dump all symbols.
+ let out = llvm_readobj().input(rust_lib_name(path)).symbols().run().stdout_utf8();
+ // Extract only lines containing `symbol`.
+ let symbol_regex = regex::Regex::new(symbol).unwrap();
+ let out = out.lines().filter(|&line| symbol_regex.find(line).is_some());
+
+ // HashSet - duplicates should be excluded!
+ let mut symbols: HashSet<String> = HashSet::new();
+ // From those lines, extract just the symbol name via `regex`, which:
+ // * always starts with "_ZN" and ends with "E" (`legacy` mangling)
+ // * always starts with "_R" (`v0` mangling)
+ for line in out {
+ if let Some(mat) = LEGACY_PATTERN.get().unwrap().find(line) {
+ symbols.insert(mat.as_str().to_string());
+ }
+ if let Some(mat) = V0_PATTERN.get().unwrap().find(line) {
+ symbols.insert(mat.as_str().to_string());
+ }
+ }
+
+ let mut symbols: Vec<String> = symbols.into_iter().collect();
+ // Sort those symbol names for deterministic comparison.
+ symbols.sort();
+ symbols
+}
diff --git a/tests/run-make/wasm-override-linker/rmake.rs b/tests/run-make/wasm-override-linker/rmake.rs
index 01bc08e990159..b04edc18eef34 100644
--- a/tests/run-make/wasm-override-linker/rmake.rs
+++ b/tests/run-make/wasm-override-linker/rmake.rs
@@ -2,6 +2,10 @@
// $ RUSTBUILD_FORCE_CLANG_BASED_TESTS=1 ./x.py test tests/run-make/wasm-override-linker/
//@ needs-force-clang-based-tests
+// FIXME(#126180): This test can only run on `x86_64-gnu-debug`, because that CI job sets
+// RUSTBUILD_FORCE_CLANG_BASED_TESTS and only runs tests which contain "clang" in their
+// name.
+// However, this test does not run at all as its name does not contain "clang".
use run_make_support::{env_var, rustc, target};
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs b/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs
new file mode 100644
index 0000000000000..5d0881029cb2f
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/q.rs
@@ -0,0 +1,2 @@
+//@ build-aux-docs
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs b/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs
new file mode 100644
index 0000000000000..fab9ec4a92b96
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/auxiliary/t.rs
@@ -0,0 +1,4 @@
+//@ aux-build:q.rs
+//@ build-aux-docs
+extern crate q;
+pub trait Tango {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/s.rs b/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/s.rs
new file mode 100644
index 0000000000000..85c460ace642f
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-transitive-no-index/s.rs
@@ -0,0 +1,16 @@
+//@ aux-build:t.rs
+//@ build-aux-docs
+//@ has q/struct.Quebec.html
+//@ has s/struct.Sierra.html
+//@ has t/trait.Tango.html
+//@ hasraw s/struct.Sierra.html 'Tango'
+//@ hasraw trait.impl/t/trait.Tango.js 'struct.Sierra.html'
+//@ hasraw search-index.js 'Tango'
+//@ hasraw search-index.js 'Sierra'
+//@ hasraw search-index.js 'Quebec'
+
+// We document multiple crates into the same output directory, which
+// merges the cross-crate information. Everything is available.
+extern crate t;
+pub struct Sierra;
+impl t::Tango for Sierra {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/q.rs b/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/q.rs
new file mode 100644
index 0000000000000..932a0b17206d6
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/q.rs
@@ -0,0 +1,5 @@
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/t.rs b/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/t.rs
new file mode 100644
index 0000000000000..c21a59c65188f
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-transitive/auxiliary/t.rs
@@ -0,0 +1,7 @@
+//@ aux-build:q.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+extern crate q;
+pub trait Tango {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-transitive/s.rs b/tests/rustdoc/cross-crate-info/cargo-transitive/s.rs
new file mode 100644
index 0000000000000..68bfc34883bd8
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-transitive/s.rs
@@ -0,0 +1,24 @@
+//@ aux-build:t.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+//@ has index.html
+//@ has index.html '//h1' 'List of all crates'
+//@ has index.html '//ul[@class="all-items"]//a[@href="q/index.html"]' 'q'
+//@ has index.html '//ul[@class="all-items"]//a[@href="s/index.html"]' 's'
+//@ has index.html '//ul[@class="all-items"]//a[@href="t/index.html"]' 't'
+//@ has q/struct.Quebec.html
+//@ has s/struct.Sierra.html
+//@ has t/trait.Tango.html
+//@ hasraw s/struct.Sierra.html 'Tango'
+//@ hasraw trait.impl/t/trait.Tango.js 'struct.Sierra.html'
+//@ hasraw search-index.js 'Tango'
+//@ hasraw search-index.js 'Sierra'
+//@ hasraw search-index.js 'Quebec'
+
+// We document multiple crates into the same output directory, which
+// merges the cross-crate information. Everything is available.
+extern crate t;
+pub struct Sierra;
+impl t::Tango for Sierra {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-two-no-index/auxiliary/f.rs b/tests/rustdoc/cross-crate-info/cargo-two-no-index/auxiliary/f.rs
new file mode 100644
index 0000000000000..abc580a388cd2
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-two-no-index/auxiliary/f.rs
@@ -0,0 +1,2 @@
+//@ build-aux-docs
+pub trait Foxtrot {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-two-no-index/e.rs b/tests/rustdoc/cross-crate-info/cargo-two-no-index/e.rs
new file mode 100644
index 0000000000000..c93298f969eab
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-two-no-index/e.rs
@@ -0,0 +1,14 @@
+//@ aux-build:f.rs
+//@ build-aux-docs
+//@ has e/enum.Echo.html
+//@ has f/trait.Foxtrot.html
+//@ hasraw e/enum.Echo.html 'Foxtrot'
+//@ hasraw trait.impl/f/trait.Foxtrot.js 'enum.Echo.html'
+//@ hasraw search-index.js 'Foxtrot'
+//@ hasraw search-index.js 'Echo'
+
+// document two crates in the same way that cargo does. do not provide
+// --enable-index-page
+extern crate f;
+pub enum Echo {}
+impl f::Foxtrot for Echo {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-two/auxiliary/f.rs b/tests/rustdoc/cross-crate-info/cargo-two/auxiliary/f.rs
new file mode 100644
index 0000000000000..a2a7033b13112
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-two/auxiliary/f.rs
@@ -0,0 +1,5 @@
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+pub trait Foxtrot {}
diff --git a/tests/rustdoc/cross-crate-info/cargo-two/e.rs b/tests/rustdoc/cross-crate-info/cargo-two/e.rs
new file mode 100644
index 0000000000000..00f86cbc34889
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/cargo-two/e.rs
@@ -0,0 +1,21 @@
+//@ aux-build:f.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+//@ has index.html
+//@ has index.html '//h1' 'List of all crates'
+//@ has index.html '//ul[@class="all-items"]//a[@href="f/index.html"]' 'f'
+//@ has index.html '//ul[@class="all-items"]//a[@href="e/index.html"]' 'e'
+//@ has e/enum.Echo.html
+//@ has f/trait.Foxtrot.html
+//@ hasraw e/enum.Echo.html 'Foxtrot'
+//@ hasraw trait.impl/f/trait.Foxtrot.js 'enum.Echo.html'
+//@ hasraw search-index.js 'Foxtrot'
+//@ hasraw search-index.js 'Echo'
+
+// document two crates in the same way that cargo does, writing them both
+// into the same output directory
+extern crate f;
+pub enum Echo {}
+impl f::Foxtrot for Echo {}
diff --git a/tests/rustdoc/cross-crate-info/index-on-last/auxiliary/f.rs b/tests/rustdoc/cross-crate-info/index-on-last/auxiliary/f.rs
new file mode 100644
index 0000000000000..abc580a388cd2
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/index-on-last/auxiliary/f.rs
@@ -0,0 +1,2 @@
+//@ build-aux-docs
+pub trait Foxtrot {}
diff --git a/tests/rustdoc/cross-crate-info/index-on-last/e.rs b/tests/rustdoc/cross-crate-info/index-on-last/e.rs
new file mode 100644
index 0000000000000..ffee898cd966d
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/index-on-last/e.rs
@@ -0,0 +1,20 @@
+//@ aux-build:f.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+//@ has index.html
+//@ has index.html '//h1' 'List of all crates'
+//@ has index.html '//ul[@class="all-items"]//a[@href="f/index.html"]' 'f'
+//@ has index.html '//ul[@class="all-items"]//a[@href="e/index.html"]' 'e'
+//@ has e/enum.Echo.html
+//@ has f/trait.Foxtrot.html
+//@ hasraw e/enum.Echo.html 'Foxtrot'
+//@ hasraw trait.impl/f/trait.Foxtrot.js 'enum.Echo.html'
+//@ hasraw search-index.js 'Foxtrot'
+//@ hasraw search-index.js 'Echo'
+
+// only declare --enable-index-page to the last rustdoc invocation
+extern crate f;
+pub enum Echo {}
+impl f::Foxtrot for Echo {}
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/q.rs b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/q.rs
new file mode 100644
index 0000000000000..932a0b17206d6
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/q.rs
@@ -0,0 +1,5 @@
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/r.rs b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/r.rs
new file mode 100644
index 0000000000000..2c0db2abc53d9
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/r.rs
@@ -0,0 +1,7 @@
+//@ aux-build:s.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+extern crate s;
+pub type Romeo = s::Sierra;
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/s.rs b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/s.rs
new file mode 100644
index 0000000000000..355d3f1aaa883
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/s.rs
@@ -0,0 +1,8 @@
+//@ aux-build:t.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+extern crate t;
+pub struct Sierra;
+impl t::Tango for Sierra {}
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/t.rs b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/t.rs
new file mode 100644
index 0000000000000..c21a59c65188f
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/kitchen-sink/auxiliary/t.rs
@@ -0,0 +1,7 @@
+//@ aux-build:q.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+extern crate q;
+pub trait Tango {}
diff --git a/tests/rustdoc/cross-crate-info/kitchen-sink/i.rs b/tests/rustdoc/cross-crate-info/kitchen-sink/i.rs
new file mode 100644
index 0000000000000..bcb9464795af2
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/kitchen-sink/i.rs
@@ -0,0 +1,30 @@
+//@ aux-build:r.rs
+//@ aux-build:q.rs
+//@ aux-build:t.rs
+//@ aux-build:s.rs
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+//@ has index.html '//h1' 'List of all crates'
+//@ has index.html
+//@ has index.html '//ul[@class="all-items"]//a[@href="i/index.html"]' 'i'
+//@ has index.html '//ul[@class="all-items"]//a[@href="q/index.html"]' 'q'
+//@ has index.html '//ul[@class="all-items"]//a[@href="r/index.html"]' 'r'
+//@ has index.html '//ul[@class="all-items"]//a[@href="s/index.html"]' 's'
+//@ has index.html '//ul[@class="all-items"]//a[@href="t/index.html"]' 't'
+//@ has q/struct.Quebec.html
+//@ has r/type.Romeo.html
+//@ has s/struct.Sierra.html
+//@ has t/trait.Tango.html
+//@ hasraw s/struct.Sierra.html 'Tango'
+//@ hasraw trait.impl/t/trait.Tango.js 'struct.Sierra.html'
+//@ hasraw search-index.js 'Quebec'
+//@ hasraw search-index.js 'Romeo'
+//@ hasraw search-index.js 'Sierra'
+//@ hasraw search-index.js 'Tango'
+//@ has type.impl/s/struct.Sierra.js
+//@ hasraw type.impl/s/struct.Sierra.js 'Tango'
+//@ hasraw type.impl/s/struct.Sierra.js 'Romeo'
+
+// document everything in the default mode
diff --git a/tests/rustdoc/cross-crate-info/single-crate-baseline/q.rs b/tests/rustdoc/cross-crate-info/single-crate-baseline/q.rs
new file mode 100644
index 0000000000000..c5e3dc0a0f4e5
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/single-crate-baseline/q.rs
@@ -0,0 +1,12 @@
+//@ build-aux-docs
+//@ doc-flags:--enable-index-page
+//@ doc-flags:-Zunstable-options
+
+//@ has index.html
+//@ has index.html '//h1' 'List of all crates'
+//@ has index.html '//ul[@class="all-items"]//a[@href="q/index.html"]' 'q'
+//@ has q/struct.Quebec.html
+//@ hasraw search-index.js 'Quebec'
+
+// there's nothing cross-crate going on here
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/single-crate-no-index/q.rs b/tests/rustdoc/cross-crate-info/single-crate-no-index/q.rs
new file mode 100644
index 0000000000000..d3e71fa0ce35f
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/single-crate-no-index/q.rs
@@ -0,0 +1,6 @@
+//@ build-aux-docs
+//@ has q/struct.Quebec.html
+//@ hasraw search-index.js 'Quebec'
+
+// there's nothing cross-crate going on here
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/transitive/auxiliary/q.rs b/tests/rustdoc/cross-crate-info/transitive/auxiliary/q.rs
new file mode 100644
index 0000000000000..5d0881029cb2f
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/transitive/auxiliary/q.rs
@@ -0,0 +1,2 @@
+//@ build-aux-docs
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/transitive/auxiliary/t.rs b/tests/rustdoc/cross-crate-info/transitive/auxiliary/t.rs
new file mode 100644
index 0000000000000..fab9ec4a92b96
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/transitive/auxiliary/t.rs
@@ -0,0 +1,4 @@
+//@ aux-build:q.rs
+//@ build-aux-docs
+extern crate q;
+pub trait Tango {}
diff --git a/tests/rustdoc/cross-crate-info/transitive/s.rs b/tests/rustdoc/cross-crate-info/transitive/s.rs
new file mode 100644
index 0000000000000..0a4e5f646ddaa
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/transitive/s.rs
@@ -0,0 +1,6 @@
+//@ aux-build:t.rs
+//@ build-aux-docs
+// simple test to see if we support building transitive crates
+extern crate t;
+pub struct Sierra;
+impl t::Tango for Sierra {}
diff --git a/tests/rustdoc/cross-crate-info/two/auxiliary/f.rs b/tests/rustdoc/cross-crate-info/two/auxiliary/f.rs
new file mode 100644
index 0000000000000..abc580a388cd2
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/two/auxiliary/f.rs
@@ -0,0 +1,2 @@
+//@ build-aux-docs
+pub trait Foxtrot {}
diff --git a/tests/rustdoc/cross-crate-info/two/e.rs b/tests/rustdoc/cross-crate-info/two/e.rs
new file mode 100644
index 0000000000000..9665af62706d1
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/two/e.rs
@@ -0,0 +1,6 @@
+//@ aux-build:f.rs
+//@ build-aux-docs
+// simple test to assert that we can do a two-level aux-build
+extern crate f;
+pub enum Echo {}
+impl f::Foxtrot for Echo {}
diff --git a/tests/rustdoc/cross-crate-info/working-dir-examples/q.rs b/tests/rustdoc/cross-crate-info/working-dir-examples/q.rs
new file mode 100644
index 0000000000000..a7ab062fd9e28
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/working-dir-examples/q.rs
@@ -0,0 +1,10 @@
+//@ build-aux-docs
+//@ doc-flags:--scrape-examples-output-path=examples
+//@ doc-flags:--scrape-examples-target-crate=q
+//@ doc-flags:-Zunstable-options
+
+//@ has examples
+
+// where will --scrape-examples-output-path resolve the path to be?
+// should be the root output directory
+pub struct Quebec;
diff --git a/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs b/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs
new file mode 100644
index 0000000000000..f8c9adcaf9cad
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/auxiliary/f.rs
@@ -0,0 +1,3 @@
+//@ build-aux-docs
+//@ unique-doc-out-dir
+pub trait Foxtrot {}
diff --git a/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/e.rs b/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/e.rs
new file mode 100644
index 0000000000000..9dcec211e1787
--- /dev/null
+++ b/tests/rustdoc/cross-crate-info/write-docs-somewhere-else/e.rs
@@ -0,0 +1,14 @@
+//@ aux-build:f.rs
+//@ build-aux-docs
+//@ has e/enum.Echo.html
+//@ !has f/trait.Foxtrot.html
+//@ hasraw e/enum.Echo.html 'Foxtrot'
+//@ hasraw trait.impl/f/trait.Foxtrot.js 'enum.Echo.html'
+//@ !hasraw search-index.js 'Foxtrot'
+//@ hasraw search-index.js 'Echo'
+
+// test the fact that our test runner will document this crate somewhere
+// else
+extern crate f;
+pub enum Echo {}
+impl f::Foxtrot for Echo {}
diff --git a/tests/ui/check-cfg/mix.stderr b/tests/ui/check-cfg/mix.stderr
index 57cbe173c7896..520cffc4b0268 100644
--- a/tests/ui/check-cfg/mix.stderr
+++ b/tests/ui/check-cfg/mix.stderr
@@ -251,7 +251,7 @@ warning: unexpected `cfg` condition value: `zebra`
LL | cfg!(target_feature = "zebra");
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, and `avx512vpopcntdq` and 199 more
+ = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, and `avx512vpopcntdq` and 201 more
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: 27 warnings emitted
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index 00abb5f5e5ca0..d780e04e729a2 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -165,7 +165,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
LL | target_feature = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `avxifma`, `avxneconvert`, `avxvnni`, `avxvnniint16`, `avxvnniint8`, `backchain`, `bf16`, `bmi1`, `bmi2`, `bti`, `bulk-memory`, `c`, `cache`, `cmpxchg16b`, `crc`, `crt-static`, `d`, `d32`, `dit`, `doloop`, `dotprod`, `dpb`, `dpb2`, `dsp`, `dsp1e2`, `dspe60`, `e`, `e1`, `e2`, `edsp`, `elrw`, `ermsb`, `exception-handling`, `extended-const`, `f`, `f16c`, `f32mm`, `f64mm`, `fcma`, `fdivdu`, `fhm`, `flagm`, `float1e2`, `float1e3`, `float3e4`, `float7e60`, `floate1`, `fma`, `fp-armv8`, `fp16`, `fp64`, `fpuv2_df`, `fpuv2_sf`, `fpuv3_df`, `fpuv3_hf`, `fpuv3_hi`, `fpuv3_sf`, `frecipe`, `frintts`, `fxsr`, `gfni`, `hard-float`, `hard-float-abi`, `hard-tp`, `high-registers`, `hvx`, `hvx-length128b`, `hwdiv`, `i8mm`, `jsconv`, `lahfsahf`, `lasx`, `lbt`, `lor`, `lse`, `lsx`, `lvz`, `lzcnt`, `m`, `mclass`, `movbe`, `mp`, `mp1e2`, `msa`, `mte`, `multivalue`, `mutable-globals`, `neon`, `nontrapping-fptoint`, `nvic`, `paca`, `pacg`, `pan`, `pclmulqdq`, `pmuv3`, `popcnt`, `power10-vector`, `power8-altivec`, `power8-vector`, `power9-altivec`, `power9-vector`, `prfchw`, `rand`, `ras`, `rclass`, `rcpc`, `rcpc2`, `rdm`, `rdrand`, `rdseed`, `reference-types`, `relax`, `relaxed-simd`, `rtm`, `sb`, `sha`, `sha2`, `sha3`, `sign-ext`, `simd128`, `sm4`, `spe`, `ssbs`, `sse`, `sse2`, `sse3`, `sse4.1`, `sse4.2`, `sse4a`, `ssse3`, `sve`, `sve2`, `sve2-aes`, `sve2-bitperm`, `sve2-sha3`, `sve2-sm4`, `tbm`, `thumb-mode`, `thumb2`, `tme`, `trust`, `trustzone`, `ual`, `unaligned-scalar-mem`, `v`, `v5te`, `v6`, `v6k`, `v6t2`, `v7`, `v8`, `v8.1a`, `v8.2a`, `v8.3a`, `v8.4a`, `v8.5a`, `v8.6a`, `v8.7a`, `vaes`, `vdsp2e60f`, `vdspv1`, `vdspv2`, `vector`, `vfp2`, `vfp3`, `vfp4`, `vh`, `virt`, `virtualization`, `vpclmulqdq`, `vsx`, `xop`, `xsave`, `xsavec`, `xsaveopt`, `xsaves`, `zba`, `zbb`, `zbc`, `zbkb`, `zbkc`, `zbkx`, `zbs`, `zdinx`, `zfh`, `zfhmin`, `zfinx`, `zhinx`, `zhinxmin`, `zk`, `zkn`, `zknd`, `zkne`, `zknh`, `zkr`, `zks`, `zksed`, `zksh`, and `zkt`
+ = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `avxifma`, `avxneconvert`, `avxvnni`, `avxvnniint16`, `avxvnniint8`, `backchain`, `bf16`, `bmi1`, `bmi2`, `bti`, `bulk-memory`, `c`, `cache`, `cmpxchg16b`, `crc`, `crt-static`, `d`, `d32`, `dit`, `doloop`, `dotprod`, `dpb`, `dpb2`, `dsp`, `dsp1e2`, `dspe60`, `e`, `e1`, `e2`, `edsp`, `elrw`, `ermsb`, `exception-handling`, `extended-const`, `f`, `f16c`, `f32mm`, `f64mm`, `fcma`, `fdivdu`, `fhm`, `flagm`, `float1e2`, `float1e3`, `float3e4`, `float7e60`, `floate1`, `fma`, `fp-armv8`, `fp16`, `fp64`, `fpuv2_df`, `fpuv2_sf`, `fpuv3_df`, `fpuv3_hf`, `fpuv3_hi`, `fpuv3_sf`, `frecipe`, `frintts`, `fxsr`, `gfni`, `hard-float`, `hard-float-abi`, `hard-tp`, `high-registers`, `hvx`, `hvx-length128b`, `hwdiv`, `i8mm`, `jsconv`, `lahfsahf`, `lasx`, `lbt`, `lor`, `lse`, `lsx`, `lvz`, `lzcnt`, `m`, `mclass`, `movbe`, `mp`, `mp1e2`, `msa`, `mte`, `multivalue`, `mutable-globals`, `neon`, `nontrapping-fptoint`, `nvic`, `paca`, `pacg`, `pan`, `pclmulqdq`, `pmuv3`, `popcnt`, `power10-vector`, `power8-altivec`, `power8-vector`, `power9-altivec`, `power9-vector`, `prfchw`, `rand`, `ras`, `rclass`, `rcpc`, `rcpc2`, `rdm`, `rdrand`, `rdseed`, `reference-types`, `relax`, `relaxed-simd`, `rtm`, `sb`, `sha`, `sha2`, `sha3`, `sha512`, `sign-ext`, `simd128`, `sm3`, `sm4`, `spe`, `ssbs`, `sse`, `sse2`, `sse3`, `sse4.1`, `sse4.2`, `sse4a`, `ssse3`, `sve`, `sve2`, `sve2-aes`, `sve2-bitperm`, `sve2-sha3`, `sve2-sm4`, `tbm`, `thumb-mode`, `thumb2`, `tme`, `trust`, `trustzone`, `ual`, `unaligned-scalar-mem`, `v`, `v5te`, `v6`, `v6k`, `v6t2`, `v7`, `v8`, `v8.1a`, `v8.2a`, `v8.3a`, `v8.4a`, `v8.5a`, `v8.6a`, `v8.7a`, `vaes`, `vdsp2e60f`, `vdspv1`, `vdspv2`, `vector`, `vfp2`, `vfp3`, `vfp4`, `vh`, `virt`, `virtualization`, `vpclmulqdq`, `vsx`, `xop`, `xsave`, `xsavec`, `xsaveopt`, `xsaves`, `zba`, `zbb`, `zbc`, `zbkb`, `zbkc`, `zbkx`, `zbs`, `zdinx`, `zfh`, `zfhmin`, `zfinx`, `zhinx`, `zhinxmin`, `zk`, `zkn`, `zknd`, `zkne`, `zknh`, `zkr`, `zks`, `zksed`, `zksh`, and `zkt`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
diff --git a/tests/ui/coherence/re-rebalance-coherence.rs b/tests/ui/coherence/re-rebalance-coherence.rs
index 5383a634617f4..9c176d5b1b12b 100644
--- a/tests/ui/coherence/re-rebalance-coherence.rs
+++ b/tests/ui/coherence/re-rebalance-coherence.rs
@@ -4,7 +4,6 @@
extern crate re_rebalance_coherence_lib as lib;
use lib::*;
-#[allow(dead_code)]
struct Oracle;
impl Backend for Oracle {}
impl<'a, T:'a, Tab> QueryFragment<Oracle> for BatchInsert<'a, T, Tab> {}
diff --git a/tests/ui/const-generics/cross_crate_complex.rs b/tests/ui/const-generics/cross_crate_complex.rs
index b44d889f5e99e..d13b69aa0cfb4 100644
--- a/tests/ui/const-generics/cross_crate_complex.rs
+++ b/tests/ui/const-generics/cross_crate_complex.rs
@@ -11,7 +11,6 @@ async fn foo() {
async_in_foo(async_out_foo::<4>().await).await;
}
-#[allow(dead_code)]
struct Faz<const N: usize>;
impl<const N: usize> Foo<N> for Faz<N> {}
diff --git a/tests/ui/const-generics/defaults/repr-c-issue-82792.rs b/tests/ui/const-generics/defaults/repr-c-issue-82792.rs
index 4bf2fa761eae8..c23187598bceb 100644
--- a/tests/ui/const-generics/defaults/repr-c-issue-82792.rs
+++ b/tests/ui/const-generics/defaults/repr-c-issue-82792.rs
@@ -2,7 +2,6 @@
//@ run-pass
-#[allow(dead_code)]
#[repr(C)]
pub struct Loaf<T: Sized, const N: usize = 1> {
head: [T; N],
diff --git a/tests/ui/const-generics/generic_const_exprs/associated-consts.rs b/tests/ui/const-generics/generic_const_exprs/associated-consts.rs
index 50a6102c605a9..5d2198f50ad92 100644
--- a/tests/ui/const-generics/generic_const_exprs/associated-consts.rs
+++ b/tests/ui/const-generics/generic_const_exprs/associated-consts.rs
@@ -16,8 +16,7 @@ impl BlockCipher for BarCipher {
const BLOCK_SIZE: usize = 32;
}
-#[allow(dead_code)]
-pub struct Block<C>(C);
+pub struct Block<C>(#[allow(dead_code)] C);
pub fn test<C: BlockCipher, const M: usize>()
where
diff --git a/tests/ui/const-generics/issues/issue-86535-2.rs b/tests/ui/const-generics/issues/issue-86535-2.rs
index ab68c6b78df34..8d064f3eeb1b7 100644
--- a/tests/ui/const-generics/issues/issue-86535-2.rs
+++ b/tests/ui/const-generics/issues/issue-86535-2.rs
@@ -9,7 +9,6 @@ pub trait Foo {
[(); Self::ASSOC_C]:;
}
-#[allow(dead_code)]
struct Bar<const N: &'static ()>;
impl<const N: &'static ()> Foo for Bar<N> {
const ASSOC_C: usize = 3;
diff --git a/tests/ui/const-generics/issues/issue-86535.rs b/tests/ui/const-generics/issues/issue-86535.rs
index 9aaf7ddc9e86e..62454f4a388a0 100644
--- a/tests/ui/const-generics/issues/issue-86535.rs
+++ b/tests/ui/const-generics/issues/issue-86535.rs
@@ -2,7 +2,6 @@
#![feature(adt_const_params, unsized_const_params, generic_const_exprs)]
#![allow(incomplete_features, unused_variables)]
-#[allow(dead_code)]
struct F<const S: &'static str>;
impl<const S: &'static str> X for F<{ S }> {
const W: usize = 3;
diff --git a/tests/ui/const-generics/transparent-maybeunit-array-wrapper.rs b/tests/ui/const-generics/transparent-maybeunit-array-wrapper.rs
index 35c41ae461520..419d605d0c875 100644
--- a/tests/ui/const-generics/transparent-maybeunit-array-wrapper.rs
+++ b/tests/ui/const-generics/transparent-maybeunit-array-wrapper.rs
@@ -6,7 +6,6 @@
use std::mem::MaybeUninit;
-#[allow(dead_code)]
#[repr(transparent)]
pub struct MaybeUninitWrapper<const N: usize>(MaybeUninit<[u64; N]>);
diff --git a/tests/ui/feature-gates/feature-gate-sha512_sm_x86.rs b/tests/ui/feature-gates/feature-gate-sha512_sm_x86.rs
new file mode 100644
index 0000000000000..176a40ecf5370
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-sha512_sm_x86.rs
@@ -0,0 +1,6 @@
+//@ only-x86_64
+#[target_feature(enable = "sha512")]
+//~^ ERROR: currently unstable
+unsafe fn foo() {}
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-sha512_sm_x86.stderr b/tests/ui/feature-gates/feature-gate-sha512_sm_x86.stderr
new file mode 100644
index 0000000000000..da9eea095a332
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-sha512_sm_x86.stderr
@@ -0,0 +1,13 @@
+error[E0658]: the target feature `sha512` is currently unstable
+ --> $DIR/feature-gate-sha512_sm_x86.rs:2:18
+ |
+LL | #[target_feature(enable = "sha512")]
+ | ^^^^^^^^^^^^^^^^^
+ |
+ = note: see issue #126624 <https://github.com/rust-lang/rust/issues/126624> for more information
+ = help: add `#![feature(sha512_sm_x86)]` to the crate attributes to enable
+ = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/generic-associated-types/missing-bounds.fixed b/tests/ui/generic-associated-types/missing-bounds.fixed
index ff69016d8626d..703d3c1e0fb17 100644
--- a/tests/ui/generic-associated-types/missing-bounds.fixed
+++ b/tests/ui/generic-associated-types/missing-bounds.fixed
@@ -2,7 +2,6 @@
use std::ops::Add;
-#[allow(dead_code)]
struct A<B>(B);
impl<B> Add for A<B> where B: Add<Output = B> {
@@ -13,7 +12,6 @@ impl<B> Add for A<B> where B: Add<Output = B> {
}
}
-#[allow(dead_code)]
struct C<B>(B);
impl<B: Add<Output = B>> Add for C<B> {
@@ -24,7 +22,6 @@ impl<B: Add<Output = B>> Add for C<B> {
}
}
-#[allow(dead_code)]
struct D<B>(B);
impl<B: std::ops::Add<Output = B>> Add for D<B> {
@@ -35,7 +32,6 @@ impl<B: std::ops::Add<Output = B>> Add for D<B> {
}
}
-#[allow(dead_code)]
struct E<B>(B);
impl<B: Add<Output = B>> Add for E<B> where B: Add<Output = B> {
diff --git a/tests/ui/generic-associated-types/missing-bounds.rs b/tests/ui/generic-associated-types/missing-bounds.rs
index 1f83356c2fa6b..f40b422887311 100644
--- a/tests/ui/generic-associated-types/missing-bounds.rs
+++ b/tests/ui/generic-associated-types/missing-bounds.rs
@@ -2,7 +2,6 @@
use std::ops::Add;
-#[allow(dead_code)]
struct A<B>(B);
impl<B> Add for A<B> where B: Add {
@@ -13,7 +12,6 @@ impl<B> Add for A<B> where B: Add {
}
}
-#[allow(dead_code)]
struct C<B>(B);
impl<B: Add> Add for C<B> {
@@ -24,7 +22,6 @@ impl<B: Add> Add for C<B> {
}
}
-#[allow(dead_code)]
struct D<B>(B);
impl<B> Add for D<B> {
@@ -35,7 +32,6 @@ impl<B> Add for D<B> {
}
}
-#[allow(dead_code)]
struct E<B>(B);
impl<B: Add> Add for E<B> where <B as Add>::Output = B {
diff --git a/tests/ui/generic-associated-types/missing-bounds.stderr b/tests/ui/generic-associated-types/missing-bounds.stderr
index 0f0dc24c06c0f..1d7d80d1b0768 100644
--- a/tests/ui/generic-associated-types/missing-bounds.stderr
+++ b/tests/ui/generic-associated-types/missing-bounds.stderr
@@ -1,5 +1,5 @@
error: equality constraints are not yet supported in `where` clauses
- --> $DIR/missing-bounds.rs:41:33
+ --> $DIR/missing-bounds.rs:37:33
|
LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B {
| ^^^^^^^^^^^^^^^^^^^^^^ not supported
@@ -11,7 +11,7 @@ LL | impl<B: Add> Add for E<B> where B: Add<Output = B> {
| ~~~~~~~~~~~~~~~~~~
error[E0308]: mismatched types
- --> $DIR/missing-bounds.rs:12:11
+ --> $DIR/missing-bounds.rs:11:11
|
LL | impl<B> Add for A<B> where B: Add {
| - expected this type parameter
@@ -24,14 +24,14 @@ LL | A(self.0 + rhs.0)
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
help: the type constructed contains `<B as Add>::Output` due to the type of the argument passed
- --> $DIR/missing-bounds.rs:12:9
+ --> $DIR/missing-bounds.rs:11:9
|
LL | A(self.0 + rhs.0)
| ^^--------------^
| |
| this argument influences the type of `A`
note: tuple struct defined here
- --> $DIR/missing-bounds.rs:6:8
+ --> $DIR/missing-bounds.rs:5:8
|
LL | struct A<B>(B);
| ^
@@ -41,7 +41,7 @@ LL | impl<B> Add for A<B> where B: Add<Output = B> {
| ++++++++++++
error[E0308]: mismatched types
- --> $DIR/missing-bounds.rs:23:14
+ --> $DIR/missing-bounds.rs:21:14
|
LL | impl<B: Add> Add for C<B> {
| - expected this type parameter
@@ -54,7 +54,7 @@ LL | Self(self.0 + rhs.0)
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
- --> $DIR/missing-bounds.rs:17:8
+ --> $DIR/missing-bounds.rs:15:8
|
LL | struct C<B>(B);
| ^
@@ -64,7 +64,7 @@ LL | impl<B: Add<Output = B>> Add for C<B> {
| ++++++++++++
error[E0369]: cannot add `B` to `B`
- --> $DIR/missing-bounds.rs:34:21
+ --> $DIR/missing-bounds.rs:31:21
|
LL | Self(self.0 + rhs.0)
| ------ ^ ----- B
@@ -77,7 +77,7 @@ LL | impl<B: std::ops::Add<Output = B>> Add for D<B> {
| +++++++++++++++++++++++++++
error[E0308]: mismatched types
- --> $DIR/missing-bounds.rs:46:14
+ --> $DIR/missing-bounds.rs:42:14
|
LL | impl<B: Add> Add for E<B> where <B as Add>::Output = B {
| - expected this type parameter
@@ -90,7 +90,7 @@ LL | Self(self.0 + rhs.0)
= note: expected type parameter `B`
found associated type `<B as Add>::Output`
note: tuple struct defined here
- --> $DIR/missing-bounds.rs:39:8
+ --> $DIR/missing-bounds.rs:35:8
|
LL | struct E<B>(B);
| ^
diff --git a/tests/ui/impl-trait/extra-impl-in-trait-impl.fixed b/tests/ui/impl-trait/extra-impl-in-trait-impl.fixed
index 3c4499f017337..886fc1d005802 100644
--- a/tests/ui/impl-trait/extra-impl-in-trait-impl.fixed
+++ b/tests/ui/impl-trait/extra-impl-in-trait-impl.fixed
@@ -1,8 +1,6 @@
//@ run-rustfix
-#[allow(dead_code)]
struct S<T>(T);
-#[allow(dead_code)]
struct S2;
impl<T: Default> Default for S<T> {
diff --git a/tests/ui/impl-trait/extra-impl-in-trait-impl.rs b/tests/ui/impl-trait/extra-impl-in-trait-impl.rs
index ac0783295242e..f3271993867cb 100644
--- a/tests/ui/impl-trait/extra-impl-in-trait-impl.rs
+++ b/tests/ui/impl-trait/extra-impl-in-trait-impl.rs
@@ -1,8 +1,6 @@
//@ run-rustfix
-#[allow(dead_code)]
struct S<T>(T);
-#[allow(dead_code)]
struct S2;
impl<T: Default> impl Default for S<T> {
diff --git a/tests/ui/impl-trait/extra-impl-in-trait-impl.stderr b/tests/ui/impl-trait/extra-impl-in-trait-impl.stderr
index 91c7da5a04fb4..5aafc8b64d4ff 100644
--- a/tests/ui/impl-trait/extra-impl-in-trait-impl.stderr
+++ b/tests/ui/impl-trait/extra-impl-in-trait-impl.stderr
@@ -1,23 +1,23 @@
error: unexpected `impl` keyword
- --> $DIR/extra-impl-in-trait-impl.rs:8:18
+ --> $DIR/extra-impl-in-trait-impl.rs:6:18
|
LL | impl<T: Default> impl Default for S<T> {
| ^^^^^ help: remove the extra `impl`
|
note: this is parsed as an `impl Trait` type, but a trait is expected at this position
- --> $DIR/extra-impl-in-trait-impl.rs:8:18
+ --> $DIR/extra-impl-in-trait-impl.rs:6:18
|
LL | impl<T: Default> impl Default for S<T> {
| ^^^^^^^^^^^^
error: unexpected `impl` keyword
- --> $DIR/extra-impl-in-trait-impl.rs:14:6
+ --> $DIR/extra-impl-in-trait-impl.rs:12:6
|
LL | impl impl Default for S2 {
| ^^^^^ help: remove the extra `impl`
|
note: this is parsed as an `impl Trait` type, but a trait is expected at this position
- --> $DIR/extra-impl-in-trait-impl.rs:14:6
+ --> $DIR/extra-impl-in-trait-impl.rs:12:6
|
LL | impl impl Default for S2 {
| ^^^^^^^^^^^^
diff --git a/tests/ui/issues/issue-5708.rs b/tests/ui/issues/issue-5708.rs
index 89ea9fbdcd8fe..ce9ef78ffcd9c 100644
--- a/tests/ui/issues/issue-5708.rs
+++ b/tests/ui/issues/issue-5708.rs
@@ -44,7 +44,6 @@ pub trait MyTrait<T> {
fn dummy(&self, t: T) -> T { panic!() }
}
-#[allow(dead_code)]
pub struct MyContainer<'a, T:'a> {
foos: Vec<&'a (dyn MyTrait<T>+'a)> ,
}
diff --git a/tests/ui/lint/dead-code/allow-unconstructed-pub-struct.rs b/tests/ui/lint/dead-code/allow-unconstructed-pub-struct.rs
deleted file mode 100644
index 8cd1524045b15..0000000000000
--- a/tests/ui/lint/dead-code/allow-unconstructed-pub-struct.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ check-pass
-
-mod ffi {
- use super::*;
-
- extern "C" {
- pub fn DomPromise_AddRef(promise: *const Promise);
- pub fn DomPromise_Release(promise: *const Promise);
- }
-}
-
-#[repr(C)]
-#[allow(unused)]
-pub struct Promise {
- private: [u8; 0],
- __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
-}
-
-pub unsafe trait RefCounted {
- unsafe fn addref(&self);
- unsafe fn release(&self);
-}
-
-unsafe impl RefCounted for Promise {
- unsafe fn addref(&self) {
- ffi::DomPromise_AddRef(self)
- }
- unsafe fn release(&self) {
- ffi::DomPromise_Release(self)
- }
-}
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/issue-59003.rs b/tests/ui/lint/dead-code/issue-59003.rs
index 319cf2db1495f..e3dcaca577889 100644
--- a/tests/ui/lint/dead-code/issue-59003.rs
+++ b/tests/ui/lint/dead-code/issue-59003.rs
@@ -4,8 +4,8 @@
#![deny(dead_code)]
-#[allow(dead_code)]
struct Foo {
+ #[allow(dead_code)]
inner: u32,
}
diff --git a/tests/ui/lint/dead-code/lint-dead-code-1.rs b/tests/ui/lint/dead-code/lint-dead-code-1.rs
index 3386dfa47470f..ddcafedf7bc5f 100644
--- a/tests/ui/lint/dead-code/lint-dead-code-1.rs
+++ b/tests/ui/lint/dead-code/lint-dead-code-1.rs
@@ -46,10 +46,11 @@ struct SemiUsedStruct;
impl SemiUsedStruct {
fn la_la_la() {}
}
-struct StructUsedAsField; //~ ERROR struct `StructUsedAsField` is never constructed
+struct StructUsedAsField;
pub struct StructUsedInEnum;
struct StructUsedInGeneric;
-pub struct PubStruct2 { //~ ERROR struct `PubStruct2` is never constructed
+pub struct PubStruct2 {
+ #[allow(dead_code)]
struct_used_as_field: *const StructUsedAsField
}
diff --git a/tests/ui/lint/dead-code/lint-dead-code-1.stderr b/tests/ui/lint/dead-code/lint-dead-code-1.stderr
index b0163df8855cd..eb728b5b93055 100644
--- a/tests/ui/lint/dead-code/lint-dead-code-1.stderr
+++ b/tests/ui/lint/dead-code/lint-dead-code-1.stderr
@@ -22,26 +22,14 @@ error: struct `PrivStruct` is never constructed
LL | struct PrivStruct;
| ^^^^^^^^^^
-error: struct `StructUsedAsField` is never constructed
- --> $DIR/lint-dead-code-1.rs:49:8
- |
-LL | struct StructUsedAsField;
- | ^^^^^^^^^^^^^^^^^
-
-error: struct `PubStruct2` is never constructed
- --> $DIR/lint-dead-code-1.rs:52:12
- |
-LL | pub struct PubStruct2 {
- | ^^^^^^^^^^
-
error: enum `priv_enum` is never used
- --> $DIR/lint-dead-code-1.rs:63:6
+ --> $DIR/lint-dead-code-1.rs:64:6
|
LL | enum priv_enum { foo2, bar2 }
| ^^^^^^^^^
error: variant `bar3` is never constructed
- --> $DIR/lint-dead-code-1.rs:66:5
+ --> $DIR/lint-dead-code-1.rs:67:5
|
LL | enum used_enum {
| --------- variant in this enum
@@ -50,25 +38,25 @@ LL | bar3
| ^^^^
error: function `priv_fn` is never used
- --> $DIR/lint-dead-code-1.rs:87:4
+ --> $DIR/lint-dead-code-1.rs:88:4
|
LL | fn priv_fn() {
| ^^^^^^^
error: function `foo` is never used
- --> $DIR/lint-dead-code-1.rs:92:4
+ --> $DIR/lint-dead-code-1.rs:93:4
|
LL | fn foo() {
| ^^^
error: function `bar` is never used
- --> $DIR/lint-dead-code-1.rs:97:4
+ --> $DIR/lint-dead-code-1.rs:98:4
|
LL | fn bar() {
| ^^^
error: function `baz` is never used
- --> $DIR/lint-dead-code-1.rs:101:4
+ --> $DIR/lint-dead-code-1.rs:102:4
|
LL | fn baz() -> impl Copy {
| ^^^
@@ -79,5 +67,5 @@ error: struct `Bar` is never constructed
LL | pub struct Bar;
| ^^^
-error: aborting due to 12 previous errors
+error: aborting due to 10 previous errors
diff --git a/tests/ui/lint/dead-code/lint-unused-adt-appeared-in-pattern.rs b/tests/ui/lint/dead-code/lint-unused-adt-appeared-in-pattern.rs
deleted file mode 100644
index 25777438456b6..0000000000000
--- a/tests/ui/lint/dead-code/lint-unused-adt-appeared-in-pattern.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![deny(dead_code)]
-
-struct Foo(u8); //~ ERROR struct `Foo` is never constructed
-
-enum Bar { //~ ERROR enum `Bar` is never used
- Var1(u8),
- Var2(u8),
-}
-
-pub trait Tr1 {
- fn f1() -> Self;
-}
-
-impl Tr1 for Foo {
- fn f1() -> Foo {
- let f = Foo(0);
- let Foo(tag) = f;
- Foo(tag)
- }
-}
-
-impl Tr1 for Bar {
- fn f1() -> Bar {
- let b = Bar::Var1(0);
- let b = if let Bar::Var1(_) = b {
- Bar::Var1(0)
- } else {
- Bar::Var2(0)
- };
- match b {
- Bar::Var1(_) => Bar::Var2(0),
- Bar::Var2(_) => Bar::Var1(0),
- }
- }
-}
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/lint-unused-adt-appeared-in-pattern.stderr b/tests/ui/lint/dead-code/lint-unused-adt-appeared-in-pattern.stderr
deleted file mode 100644
index 7c1a4b4597755..0000000000000
--- a/tests/ui/lint/dead-code/lint-unused-adt-appeared-in-pattern.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: struct `Foo` is never constructed
- --> $DIR/lint-unused-adt-appeared-in-pattern.rs:3:8
- |
-LL | struct Foo(u8);
- | ^^^
- |
-note: the lint level is defined here
- --> $DIR/lint-unused-adt-appeared-in-pattern.rs:1:9
- |
-LL | #![deny(dead_code)]
- | ^^^^^^^^^
-
-error: enum `Bar` is never used
- --> $DIR/lint-unused-adt-appeared-in-pattern.rs:5:6
- |
-LL | enum Bar {
- | ^^^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/lint/dead-code/not-lint-used-adt-appeared-in-pattern.rs b/tests/ui/lint/dead-code/not-lint-used-adt-appeared-in-pattern.rs
deleted file mode 100644
index 43a2e43190433..0000000000000
--- a/tests/ui/lint/dead-code/not-lint-used-adt-appeared-in-pattern.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ check-pass
-
-#![deny(dead_code)]
-
-#[repr(u8)]
-#[derive(Copy, Clone, Debug)]
-pub enum RecordField {
- Target = 1,
- Level,
- Module,
- File,
- Line,
- NumArgs,
-}
-
-unsafe trait Pod {}
-
-#[repr(transparent)]
-struct RecordFieldWrapper(RecordField);
-
-unsafe impl Pod for RecordFieldWrapper {}
-
-fn try_read<T: Pod>(buf: &[u8]) -> T {
- unsafe { std::ptr::read_unaligned(buf.as_ptr() as *const T) }
-}
-
-pub fn foo(buf: &[u8]) -> RecordField {
- let RecordFieldWrapper(tag) = try_read(buf);
- tag
-}
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/unconstructible-pub-struct.rs b/tests/ui/lint/dead-code/unconstructible-pub-struct.rs
deleted file mode 100644
index 2202cbb673098..0000000000000
--- a/tests/ui/lint/dead-code/unconstructible-pub-struct.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![feature(never_type)]
-#![deny(dead_code)]
-
-pub struct T1(!);
-pub struct T2(());
-pub struct T3<X>(std::marker::PhantomData<X>);
-
-pub struct T4 {
- _x: !,
-}
-
-pub struct T5<X> {
- _x: !,
- _y: X,
-}
-
-pub struct T6 {
- _x: (),
-}
-
-pub struct T7<X> {
- _x: (),
- _y: X,
-}
-
-pub struct T8<X> {
- _x: std::marker::PhantomData<X>,
-}
-
-pub struct T9<X> { //~ ERROR struct `T9` is never constructed
- _x: std::marker::PhantomData<X>,
- _y: i32,
-}
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/unconstructible-pub-struct.stderr b/tests/ui/lint/dead-code/unconstructible-pub-struct.stderr
deleted file mode 100644
index a3dde042bbe15..0000000000000
--- a/tests/ui/lint/dead-code/unconstructible-pub-struct.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error: struct `T9` is never constructed
- --> $DIR/unconstructible-pub-struct.rs:30:12
- |
-LL | pub struct T9<X> {
- | ^^
- |
-note: the lint level is defined here
- --> $DIR/unconstructible-pub-struct.rs:2:9
- |
-LL | #![deny(dead_code)]
- | ^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.rs b/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.rs
index 658cc3d6c613a..5b755d62a0598 100644
--- a/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.rs
+++ b/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.rs
@@ -1,9 +1,8 @@
#![deny(dead_code)]
struct T1; //~ ERROR struct `T1` is never constructed
-struct T2; //~ ERROR struct `T2` is never constructed
-pub struct T3(i32); //~ ERROR struct `T3` is never constructed
-pub struct T4(i32); //~ ERROR field `0` is never read
+pub struct T2(i32); //~ ERROR field `0` is never read
+struct T3;
trait Trait1 { //~ ERROR trait `Trait1` is never used
const UNUSED: i32;
@@ -12,13 +11,13 @@ trait Trait1 { //~ ERROR trait `Trait1` is never used
}
pub trait Trait2 {
- const MAY_USED: i32;
- fn may_used(&self) {}
+ const USED: i32;
+ fn used(&self) {}
}
pub trait Trait3 {
- const MAY_USED: i32;
- fn may_used() -> Self;
+ const USED: i32;
+ fn construct_self() -> Self;
}
impl Trait1 for T1 {
@@ -31,34 +30,23 @@ impl Trait1 for T1 {
impl Trait1 for T2 {
const UNUSED: i32 = 0;
fn construct_self() -> Self {
- Self
+ T2(0)
}
}
impl Trait2 for T1 {
- const MAY_USED: i32 = 0;
+ const USED: i32 = 0;
}
impl Trait2 for T2 {
- const MAY_USED: i32 = 0;
-}
-
-impl Trait2 for T3 {
- const MAY_USED: i32 = 0;
+ const USED: i32 = 0;
}
-impl Trait3 for T2 {
- const MAY_USED: i32 = 0;
- fn may_used() -> Self {
+impl Trait3 for T3 {
+ const USED: i32 = 0;
+ fn construct_self() -> Self {
Self
}
}
-impl Trait3 for T4 {
- const MAY_USED: i32 = 0;
- fn may_used() -> Self {
- T4(0)
- }
-}
-
fn main() {}
diff --git a/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.stderr b/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.stderr
index 08c7a5cb4b062..2441a3f868dc2 100644
--- a/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.stderr
+++ b/tests/ui/lint/dead-code/unused-adt-impl-pub-trait-with-assoc-const.stderr
@@ -10,22 +10,10 @@ note: the lint level is defined here
LL | #![deny(dead_code)]
| ^^^^^^^^^
-error: struct `T2` is never constructed
- --> $DIR/unused-adt-impl-pub-trait-with-assoc-const.rs:4:8
- |
-LL | struct T2;
- | ^^
-
-error: struct `T3` is never constructed
- --> $DIR/unused-adt-impl-pub-trait-with-assoc-const.rs:5:12
- |
-LL | pub struct T3(i32);
- | ^^
-
error: field `0` is never read
- --> $DIR/unused-adt-impl-pub-trait-with-assoc-const.rs:6:15
+ --> $DIR/unused-adt-impl-pub-trait-with-assoc-const.rs:4:15
|
-LL | pub struct T4(i32);
+LL | pub struct T2(i32);
| -- ^^^
| |
| field in this struct
@@ -33,10 +21,10 @@ LL | pub struct T4(i32);
= help: consider removing this field
error: trait `Trait1` is never used
- --> $DIR/unused-adt-impl-pub-trait-with-assoc-const.rs:8:7
+ --> $DIR/unused-adt-impl-pub-trait-with-assoc-const.rs:7:7
|
LL | trait Trait1 {
| ^^^^^^
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
diff --git a/tests/ui/lint/dead-code/unused-assoc-const.rs b/tests/ui/lint/dead-code/unused-assoc-const.rs
deleted file mode 100644
index 36e8315ad3605..0000000000000
--- a/tests/ui/lint/dead-code/unused-assoc-const.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![deny(dead_code)]
-
-trait Trait {
- const UNUSED_CONST: i32; //~ ERROR associated constant `UNUSED_CONST` is never used
- const USED_CONST: i32;
-
- fn foo(&self) {}
-}
-
-pub struct T(());
-
-impl Trait for T {
- const UNUSED_CONST: i32 = 0;
- const USED_CONST: i32 = 1;
-}
-
-fn main() {
- T(()).foo();
- T::USED_CONST;
-}
diff --git a/tests/ui/lint/dead-code/unused-assoc-const.stderr b/tests/ui/lint/dead-code/unused-assoc-const.stderr
deleted file mode 100644
index 78296d706638b..0000000000000
--- a/tests/ui/lint/dead-code/unused-assoc-const.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error: associated constant `UNUSED_CONST` is never used
- --> $DIR/unused-assoc-const.rs:4:11
- |
-LL | trait Trait {
- | ----- associated constant in this trait
-LL | const UNUSED_CONST: i32;
- | ^^^^^^^^^^^^
- |
-note: the lint level is defined here
- --> $DIR/unused-assoc-const.rs:1:9
- |
-LL | #![deny(dead_code)]
- | ^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/lint/dead-code/unused-impl-for-non-adts.rs b/tests/ui/lint/dead-code/unused-impl-for-non-adts.rs
deleted file mode 100644
index 46065dcee81e0..0000000000000
--- a/tests/ui/lint/dead-code/unused-impl-for-non-adts.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![deny(dead_code)]
-
-struct Foo; //~ ERROR struct `Foo` is never constructed
-
-trait Trait { //~ ERROR trait `Trait` is never used
- fn foo(&self) {}
-}
-
-impl Trait for Foo {}
-
-impl Trait for [Foo] {}
-impl<const N: usize> Trait for [Foo; N] {}
-
-impl Trait for *const Foo {}
-impl Trait for *mut Foo {}
-
-impl Trait for &Foo {}
-impl Trait for &&Foo {}
-impl Trait for &mut Foo {}
-
-impl Trait for [&Foo] {}
-impl Trait for &[Foo] {}
-impl Trait for &*const Foo {}
-
-pub trait Trait2 {
- fn foo(&self) {}
-}
-
-impl Trait2 for Foo {}
-
-impl Trait2 for [Foo] {}
-impl<const N: usize> Trait2 for [Foo; N] {}
-
-impl Trait2 for *const Foo {}
-impl Trait2 for *mut Foo {}
-
-impl Trait2 for &Foo {}
-impl Trait2 for &&Foo {}
-impl Trait2 for &mut Foo {}
-
-impl Trait2 for [&Foo] {}
-impl Trait2 for &[Foo] {}
-impl Trait2 for &*const Foo {}
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/unused-impl-for-non-adts.stderr b/tests/ui/lint/dead-code/unused-impl-for-non-adts.stderr
deleted file mode 100644
index e61fc403e810d..0000000000000
--- a/tests/ui/lint/dead-code/unused-impl-for-non-adts.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: struct `Foo` is never constructed
- --> $DIR/unused-impl-for-non-adts.rs:3:8
- |
-LL | struct Foo;
- | ^^^
- |
-note: the lint level is defined here
- --> $DIR/unused-impl-for-non-adts.rs:1:9
- |
-LL | #![deny(dead_code)]
- | ^^^^^^^^^
-
-error: trait `Trait` is never used
- --> $DIR/unused-impl-for-non-adts.rs:5:7
- |
-LL | trait Trait {
- | ^^^^^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/lint/dead-code/unused-pub-struct.rs b/tests/ui/lint/dead-code/unused-pub-struct.rs
deleted file mode 100644
index aaf4dd612de4d..0000000000000
--- a/tests/ui/lint/dead-code/unused-pub-struct.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![deny(dead_code)]
-
-pub struct NotLint1(());
-pub struct NotLint2(std::marker::PhantomData<i32>);
-
-pub struct NeverConstructed(i32); //~ ERROR struct `NeverConstructed` is never constructed
-
-impl NeverConstructed {
- pub fn not_construct_self(&self) {}
-}
-
-impl Clone for NeverConstructed {
- fn clone(&self) -> NeverConstructed {
- NeverConstructed(0)
- }
-}
-
-pub trait Trait {
- fn not_construct_self(&self);
-}
-
-impl Trait for NeverConstructed {
- fn not_construct_self(&self) {
- self.0;
- }
-}
-
-pub struct Constructed(i32);
-
-impl Constructed {
- pub fn construct_self() -> Self {
- Constructed(0)
- }
-}
-
-impl Clone for Constructed {
- fn clone(&self) -> Constructed {
- Constructed(0)
- }
-}
-
-impl Trait for Constructed {
- fn not_construct_self(&self) {
- self.0;
- }
-}
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/unused-pub-struct.stderr b/tests/ui/lint/dead-code/unused-pub-struct.stderr
deleted file mode 100644
index 3667ddb97bd3e..0000000000000
--- a/tests/ui/lint/dead-code/unused-pub-struct.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error: struct `NeverConstructed` is never constructed
- --> $DIR/unused-pub-struct.rs:6:12
- |
-LL | pub struct NeverConstructed(i32);
- | ^^^^^^^^^^^^^^^^
- |
-note: the lint level is defined here
- --> $DIR/unused-pub-struct.rs:1:9
- |
-LL | #![deny(dead_code)]
- | ^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/lint/dead-code/unused-struct-derive-default.rs b/tests/ui/lint/dead-code/unused-struct-derive-default.rs
index f20b7cb66ee51..330ad32dd5709 100644
--- a/tests/ui/lint/dead-code/unused-struct-derive-default.rs
+++ b/tests/ui/lint/dead-code/unused-struct-derive-default.rs
@@ -22,5 +22,4 @@ pub struct T2 {
fn main() {
let _x: Used = Default::default();
- let _e: E = Default::default();
}
diff --git a/tests/ui/lint/dead-code/unused-struct-derive-default.stderr b/tests/ui/lint/dead-code/unused-struct-derive-default.stderr
index 7422f9a39f312..bbb0bd7be7064 100644
--- a/tests/ui/lint/dead-code/unused-struct-derive-default.stderr
+++ b/tests/ui/lint/dead-code/unused-struct-derive-default.stderr
@@ -4,6 +4,7 @@ error: struct `T` is never constructed
LL | struct T;
| ^
|
+ = note: `T` has a derived impl for the trait `Default`, but this is intentionally ignored during dead code analysis
note: the lint level is defined here
--> $DIR/unused-struct-derive-default.rs:1:9
|
diff --git a/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs b/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs
deleted file mode 100644
index e8116d83ebf1c..0000000000000
--- a/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![deny(dead_code)]
-
-struct T1; //~ ERROR struct `T1` is never constructed
-
-trait Foo { type Unused; } //~ ERROR trait `Foo` is never used
-impl Foo for T1 { type Unused = Self; }
-
-pub trait Bar { type Used; }
-impl Bar for T1 { type Used = Self; }
-
-fn main() {}
diff --git a/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr b/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr
deleted file mode 100644
index ab73c64063431..0000000000000
--- a/tests/ui/lint/dead-code/unused-trait-with-assoc-ty.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: struct `T1` is never constructed
- --> $DIR/unused-trait-with-assoc-ty.rs:3:8
- |
-LL | struct T1;
- | ^^
- |
-note: the lint level is defined here
- --> $DIR/unused-trait-with-assoc-ty.rs:1:9
- |
-LL | #![deny(dead_code)]
- | ^^^^^^^^^
-
-error: trait `Foo` is never used
- --> $DIR/unused-trait-with-assoc-ty.rs:5:7
- |
-LL | trait Foo { type Unused; }
- | ^^^
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/parser/issues/issue-105366.fixed b/tests/ui/parser/issues/issue-105366.fixed
index 95419dc07f2cc..7157b647524dd 100644
--- a/tests/ui/parser/issues/issue-105366.fixed
+++ b/tests/ui/parser/issues/issue-105366.fixed
@@ -1,6 +1,5 @@
//@ run-rustfix
-#[allow(dead_code)]
struct Foo;
impl From<i32> for Foo {
diff --git a/tests/ui/parser/issues/issue-105366.rs b/tests/ui/parser/issues/issue-105366.rs
index 3278b73799125..dc3cb8b343d32 100644
--- a/tests/ui/parser/issues/issue-105366.rs
+++ b/tests/ui/parser/issues/issue-105366.rs
@@ -1,6 +1,5 @@
//@ run-rustfix
-#[allow(dead_code)]
struct Foo;
fn From<i32> for Foo {
diff --git a/tests/ui/parser/issues/issue-105366.stderr b/tests/ui/parser/issues/issue-105366.stderr
index 195305a2ec889..18c04dfaf2088 100644
--- a/tests/ui/parser/issues/issue-105366.stderr
+++ b/tests/ui/parser/issues/issue-105366.stderr
@@ -1,5 +1,5 @@
error: you might have meant to write `impl` instead of `fn`
- --> $DIR/issue-105366.rs:6:1
+ --> $DIR/issue-105366.rs:5:1
|
LL | fn From<i32> for Foo {
| ^^
diff --git a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed
index e9c89807fa566..a851300a9828e 100644
--- a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed
+++ b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed
@@ -1,8 +1,7 @@
// Regression test for issues #100790 and #106439.
//@ run-rustfix
-#[allow(dead_code)]
-pub struct Example(usize)
+pub struct Example(#[allow(dead_code)] usize)
where
(): Sized;
//~^^^ ERROR where clauses are not allowed before tuple struct bodies
diff --git a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs
index 3bd0f51ec2cbe..10f435859f15a 100644
--- a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs
+++ b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs
@@ -1,11 +1,10 @@
// Regression test for issues #100790 and #106439.
//@ run-rustfix
-#[allow(dead_code)]
pub struct Example
where
(): Sized,
-(usize);
+(#[allow(dead_code)] usize);
//~^^^ ERROR where clauses are not allowed before tuple struct bodies
struct _Demo
diff --git a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr
index 77eafa6bea336..ddbf237e8662b 100644
--- a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr
+++ b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr
@@ -1,23 +1,23 @@
error: where clauses are not allowed before tuple struct bodies
- --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:6:1
+ --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:5:1
|
LL | pub struct Example
| ------- while parsing this tuple struct
LL | / where
LL | | (): Sized,
| |______________^ unexpected where clause
-LL | (usize);
- | ------- the struct body
+LL | (#[allow(dead_code)] usize);
+ | --------------------------- the struct body
|
help: move the body before the where clause
|
-LL ~ pub struct Example(usize)
+LL ~ pub struct Example(#[allow(dead_code)] usize)
LL | where
LL ~ (): Sized;
|
error: where clauses are not allowed before tuple struct bodies
- --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:12:1
+ --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:11:1
|
LL | struct _Demo
| ----- while parsing this tuple struct
diff --git a/tests/ui/pattern/issue-22546.rs b/tests/ui/pattern/issue-22546.rs
index d5c5b68be78d7..fd1d5fb6c4775 100644
--- a/tests/ui/pattern/issue-22546.rs
+++ b/tests/ui/pattern/issue-22546.rs
@@ -15,7 +15,7 @@ impl<T: ::std::fmt::Display> Foo<T> {
}
}
-trait Tr {
+trait Tr { //~ WARN trait `Tr` is never used
type U;
}
diff --git a/tests/ui/pattern/issue-22546.stderr b/tests/ui/pattern/issue-22546.stderr
new file mode 100644
index 0000000000000..e067a95e4226c
--- /dev/null
+++ b/tests/ui/pattern/issue-22546.stderr
@@ -0,0 +1,10 @@
+warning: trait `Tr` is never used
+ --> $DIR/issue-22546.rs:18:7
+ |
+LL | trait Tr {
+ | ^^
+ |
+ = note: `#[warn(dead_code)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/pub/pub-ident-struct-4.fixed b/tests/ui/pub/pub-ident-struct-4.fixed
index a62ece43eced3..5fedbb7243749 100644
--- a/tests/ui/pub/pub-ident-struct-4.fixed
+++ b/tests/ui/pub/pub-ident-struct-4.fixed
@@ -1,7 +1,6 @@
//@ run-rustfix
-#[allow(dead_code)]
-pub struct T(String);
+pub struct T(#[allow(dead_code)] String);
//~^ ERROR missing `struct` for struct definition
fn main() {}
diff --git a/tests/ui/pub/pub-ident-struct-4.rs b/tests/ui/pub/pub-ident-struct-4.rs
index 0d56a31beaf1c..5c721c25a7815 100644
--- a/tests/ui/pub/pub-ident-struct-4.rs
+++ b/tests/ui/pub/pub-ident-struct-4.rs
@@ -1,7 +1,6 @@
//@ run-rustfix
-#[allow(dead_code)]
-pub T(String);
+pub T(#[allow(dead_code)] String);
//~^ ERROR missing `struct` for struct definition
fn main() {}
diff --git a/tests/ui/pub/pub-ident-struct-4.stderr b/tests/ui/pub/pub-ident-struct-4.stderr
index d3072464e05cd..04965a1a73720 100644
--- a/tests/ui/pub/pub-ident-struct-4.stderr
+++ b/tests/ui/pub/pub-ident-struct-4.stderr
@@ -1,12 +1,12 @@
error: missing `struct` for struct definition
- --> $DIR/pub-ident-struct-4.rs:4:1
+ --> $DIR/pub-ident-struct-4.rs:3:1
|
-LL | pub T(String);
+LL | pub T(#[allow(dead_code)] String);
| ^^^^^
|
help: add `struct` here to parse `T` as a struct
|
-LL | pub struct T(String);
+LL | pub struct T(#[allow(dead_code)] String);
| ++++++
error: aborting due to 1 previous error
diff --git a/tests/ui/regions/regions-issue-21422.rs b/tests/ui/regions/regions-issue-21422.rs
index 67852a6f5de0d..54beed9b3ac2b 100644
--- a/tests/ui/regions/regions-issue-21422.rs
+++ b/tests/ui/regions/regions-issue-21422.rs
@@ -5,7 +5,6 @@
//@ pretty-expanded FIXME #23616
-#[allow(dead_code)]
pub struct P<'a> {
_ptr: *const &'a u8,
}
diff --git a/tests/ui/structs-enums/newtype-struct-with-dtor.rs b/tests/ui/structs-enums/newtype-struct-with-dtor.rs
index 16439a7fedd3e..19672e41c9a30 100644
--- a/tests/ui/structs-enums/newtype-struct-with-dtor.rs
+++ b/tests/ui/structs-enums/newtype-struct-with-dtor.rs
@@ -3,10 +3,8 @@
#![allow(unused_variables)]
//@ pretty-expanded FIXME #23616
-#[allow(dead_code)]
pub struct Fd(u32);
-#[allow(dead_code)]
fn foo(a: u32) {}
impl Drop for Fd {
diff --git a/tests/ui/structs-enums/uninstantiable-struct.rs b/tests/ui/structs-enums/uninstantiable-struct.rs
index 1074dbcd6e6b5..97bc7d8414e7f 100644
--- a/tests/ui/structs-enums/uninstantiable-struct.rs
+++ b/tests/ui/structs-enums/uninstantiable-struct.rs
@@ -1,5 +1,4 @@
//@ run-pass
-#[allow(dead_code)]
-pub struct Z(&'static Z);
+pub struct Z(#[allow(dead_code)] &'static Z);
pub fn main() {}
diff --git a/tests/ui/suggestions/derive-clone-for-eq.fixed b/tests/ui/suggestions/derive-clone-for-eq.fixed
index cf800c6e47d87..4dc362f947875 100644
--- a/tests/ui/suggestions/derive-clone-for-eq.fixed
+++ b/tests/ui/suggestions/derive-clone-for-eq.fixed
@@ -1,7 +1,6 @@
//@ run-rustfix
// https://github.com/rust-lang/rust/issues/79076
-#[allow(dead_code)]
#[derive(Clone, Eq)] //~ ERROR [E0277]
pub struct Struct<T: std::clone::Clone>(T);
diff --git a/tests/ui/suggestions/derive-clone-for-eq.rs b/tests/ui/suggestions/derive-clone-for-eq.rs
index 84736426bac0d..b3635000f1658 100644
--- a/tests/ui/suggestions/derive-clone-for-eq.rs
+++ b/tests/ui/suggestions/derive-clone-for-eq.rs
@@ -1,7 +1,6 @@
//@ run-rustfix
// https://github.com/rust-lang/rust/issues/79076
-#[allow(dead_code)]
#[derive(Clone, Eq)] //~ ERROR [E0277]
pub struct Struct<T>(T);
diff --git a/tests/ui/suggestions/derive-clone-for-eq.stderr b/tests/ui/suggestions/derive-clone-for-eq.stderr
index 54670fbffcfb9..6fae6e1316df0 100644
--- a/tests/ui/suggestions/derive-clone-for-eq.stderr
+++ b/tests/ui/suggestions/derive-clone-for-eq.stderr
@@ -1,11 +1,11 @@
error[E0277]: the trait bound `T: Clone` is not satisfied
- --> $DIR/derive-clone-for-eq.rs:5:17
+ --> $DIR/derive-clone-for-eq.rs:4:17
|
LL | #[derive(Clone, Eq)]
| ^^ the trait `Clone` is not implemented for `T`, which is required by `Struct<T>: PartialEq`
|
note: required for `Struct<T>` to implement `PartialEq`
- --> $DIR/derive-clone-for-eq.rs:8:19
+ --> $DIR/derive-clone-for-eq.rs:7:19
|
LL | impl<T: Clone, U> PartialEq<U> for Struct<T>
| ----- ^^^^^^^^^^^^ ^^^^^^^^^
diff --git a/tests/ui/suggestions/option-content-move.fixed b/tests/ui/suggestions/option-content-move.fixed
index ef07d55871e7e..4a5a9483c20c8 100644
--- a/tests/ui/suggestions/option-content-move.fixed
+++ b/tests/ui/suggestions/option-content-move.fixed
@@ -1,5 +1,4 @@
//@ run-rustfix
-#[allow(dead_code)]
pub struct LipogramCorpora {
selections: Vec<(char, Option<String>)>,
}
@@ -18,7 +17,6 @@ impl LipogramCorpora {
}
}
-#[allow(dead_code)]
pub struct LipogramCorpora2 {
selections: Vec<(char, Result<String, String>)>,
}
diff --git a/tests/ui/suggestions/option-content-move.rs b/tests/ui/suggestions/option-content-move.rs
index 5be6358fd6a57..90d05c7439970 100644
--- a/tests/ui/suggestions/option-content-move.rs
+++ b/tests/ui/suggestions/option-content-move.rs
@@ -1,5 +1,4 @@
//@ run-rustfix
-#[allow(dead_code)]
pub struct LipogramCorpora {
selections: Vec<(char, Option<String>)>,
}
@@ -18,7 +17,6 @@ impl LipogramCorpora {
}
}
-#[allow(dead_code)]
pub struct LipogramCorpora2 {
selections: Vec<(char, Result<String, String>)>,
}
diff --git a/tests/ui/suggestions/option-content-move.stderr b/tests/ui/suggestions/option-content-move.stderr
index b4ec5b180d210..a382a04344aeb 100644
--- a/tests/ui/suggestions/option-content-move.stderr
+++ b/tests/ui/suggestions/option-content-move.stderr
@@ -1,5 +1,5 @@
error[E0507]: cannot move out of `selection.1` which is behind a shared reference
- --> $DIR/option-content-move.rs:11:20
+ --> $DIR/option-content-move.rs:10:20
|
LL | if selection.1.unwrap().contains(selection.0) {
| ^^^^^^^^^^^ -------- `selection.1` moved due to this method call
@@ -19,7 +19,7 @@ LL | if selection.1.clone().unwrap().contains(selection.0) {
| ++++++++
error[E0507]: cannot move out of `selection.1` which is behind a shared reference
- --> $DIR/option-content-move.rs:30:20
+ --> $DIR/option-content-move.rs:28:20
|
LL | if selection.1.unwrap().contains(selection.0) {
| ^^^^^^^^^^^ -------- `selection.1` moved due to this method call
diff --git a/tests/ui/traits/object/generics.rs b/tests/ui/traits/object/generics.rs
index 0ae562c0d30a0..462b0bc5bb77f 100644
--- a/tests/ui/traits/object/generics.rs
+++ b/tests/ui/traits/object/generics.rs
@@ -7,7 +7,6 @@ pub trait Trait2<A> {
fn doit(&self) -> A;
}
-#[allow(dead_code)]
pub struct Impl<A1, A2, A3> {
m1: marker::PhantomData<(A1,A2,A3)>,
/*