user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor target checking, move out of context.rs and rename MaybeWarn to Policy

Browse source
This commit is contained in:
Jana Dönszelmann 2025-08-16 18:04:58 +02:00
parent 9be8effb3f
commit 2158e2d4d7
No known key found for this signature in database
53 changed files with 509 additions and 433 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock
View file

@ -3481,7 +3481,6 @@ dependencies = [
name = "rustc_attr_parsing"
version = "0.0.0"
dependencies = [
"itertools",
"rustc_abi",
"rustc_ast",
"rustc_ast_pretty",

1
compiler/rustc_attr_parsing/Cargo.toml
View file

@ -5,7 +5,6 @@ edition = "2024"
[dependencies]
# tidy-alphabetical-start
itertools = "0.12"
rustc_abi = { path = "../rustc_abi" }
rustc_ast = { path = "../rustc_ast" }
rustc_ast_pretty = { path = "../rustc_ast_pretty" }

5
compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
View file

@ -6,10 +6,11 @@ use rustc_hir::{MethodKind, Target};
use rustc_span::{Span, Symbol, sym};
use super::{CombineAttributeParser, ConvertFn};
use crate::context::MaybeWarn::{Allow, Warn};
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Warn};
pub(crate) struct AllowInternalUnstableParser;
impl<S: Stage> CombineAttributeParser<S> for AllowInternalUnstableParser {

5
compiler/rustc_attr_parsing/src/attributes/body.rs
View file

@ -5,8 +5,9 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Symbol, sym};
use super::{NoArgsAttributeParser, OnDuplicate};
use crate::context::MaybeWarn::Allow;
use crate::context::{AllowedTargets, Stage};
use crate::context::Stage;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
pub(crate) struct CoroutineParser;

5
compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
View file

@ -8,10 +8,11 @@ use super::{
AcceptMapping, AttributeOrder, AttributeParser, CombineAttributeParser, ConvertFn,
NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
};
use crate::context::MaybeWarn::{Allow, Warn};
use crate::context::{AcceptContext, AllowedTargets, FinalizeContext, Stage};
use crate::context::{AcceptContext, FinalizeContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics::{NakedFunctionIncompatibleAttribute, NullOnExport};
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Warn};
pub(crate) struct OptimizeParser;

6
compiler/rustc_attr_parsing/src/attributes/confusables.rs
View file

@ -5,9 +5,11 @@ use rustc_span::{Span, Symbol, sym};
use thin_vec::ThinVec;
use super::{AcceptMapping, AttributeParser};
use crate::context::MaybeWarn::Allow;
use crate::context::{AllowedTargets, FinalizeContext, Stage};
use crate::context::{FinalizeContext, Stage};
use crate::session_diagnostics;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
#[derive(Default)]
pub(crate) struct ConfusablesParser {
confusables: ThinVec<Symbol>,

6
compiler/rustc_attr_parsing/src/attributes/deprecation.rs
View file

@ -5,10 +5,12 @@ use rustc_span::{Span, Symbol, sym};
use super::util::parse_version;
use super::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::MaybeWarn::{Allow, Error};
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Error};
pub(crate) struct DeprecationParser;
fn get<S: Stage>(

4
compiler/rustc_attr_parsing/src/attributes/dummy.rs
View file

@ -3,8 +3,10 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Symbol, sym};
use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::{ALL_TARGETS, AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::{ALL_TARGETS, AllowedTargets};
pub(crate) struct DummyParser;
impl<S: Stage> SingleAttributeParser<S> for DummyParser {
const PATH: &[Symbol] = &[sym::rustc_dummy];

6
compiler/rustc_attr_parsing/src/attributes/inline.rs
View file

@ -10,9 +10,11 @@ use rustc_span::{Symbol, sym};
use super::{AcceptContext, AttributeOrder, OnDuplicate};
use crate::attributes::SingleAttributeParser;
use crate::context::MaybeWarn::{Allow, Warn};
use crate::context::{AllowedTargets, Stage};
use crate::context::Stage;
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Warn};
pub(crate) struct InlineParser;
impl<S: Stage> SingleAttributeParser<S> for InlineParser {

8
compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
View file

@ -7,10 +7,14 @@ use rustc_span::{Span, Symbol, sym};
use crate::attributes::{
AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
};
use crate::context::MaybeWarn::Allow;
use crate::context::{ALL_TARGETS, AcceptContext, AllowedTargets, Stage, parse_single_integer};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics::{LinkOrdinalOutOfRange, NullOnLinkSection};
use crate::target_checking::Policy::Allow;
use crate::target_checking::{ALL_TARGETS, AllowedTargets};
use super::util::parse_single_integer;
pub(crate) struct LinkNameParser;
impl<S: Stage> SingleAttributeParser<S> for LinkNameParser {

6
compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs
View file

@ -3,8 +3,10 @@ use rustc_hir::{MethodKind, Target};
use rustc_span::{Span, Symbol, sym};
use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
use crate::context::MaybeWarn::{Allow, Error};
use crate::context::{AllowedTargets, Stage};
use crate::context::Stage;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Error};
pub(crate) struct AsPtrParser;
impl<S: Stage> NoArgsAttributeParser<S> for AsPtrParser {
const PATH: &[Symbol] = &[sym::rustc_as_ptr];

6
compiler/rustc_attr_parsing/src/attributes/loop_match.rs
View file

@ -3,8 +3,10 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Span, Symbol, sym};
use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
use crate::context::MaybeWarn::Allow;
use crate::context::{AllowedTargets, Stage};
use crate::context::Stage;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
pub(crate) struct LoopMatchParser;
impl<S: Stage> NoArgsAttributeParser<S> for LoopMatchParser {
const PATH: &[Symbol] = &[sym::loop_match];

6
compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
View file

@ -6,10 +6,12 @@ use rustc_span::{Span, Symbol, sym};
use thin_vec::ThinVec;
use crate::attributes::{AcceptMapping, AttributeParser, NoArgsAttributeParser, OnDuplicate};
use crate::context::MaybeWarn::{Allow, Error, Warn};
use crate::context::{AcceptContext, AllowedTargets, FinalizeContext, Stage};
use crate::context::{AcceptContext, FinalizeContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Error, Warn};
pub(crate) struct MacroEscapeParser;
impl<S: Stage> NoArgsAttributeParser<S> for MacroEscapeParser {
const PATH: &[Symbol] = &[sym::macro_escape];

3
compiler/rustc_attr_parsing/src/attributes/mod.rs
View file

@ -21,9 +21,10 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Span, Symbol};
use thin_vec::ThinVec;
use crate::context::{AcceptContext, AllowedTargets, FinalizeContext, Stage};
use crate::context::{AcceptContext, FinalizeContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics::UnusedMultiple;
use crate::target_checking::AllowedTargets;
pub(crate) mod allow_unstable;
pub(crate) mod body;

6
compiler/rustc_attr_parsing/src/attributes/must_use.rs
View file

@ -5,10 +5,12 @@ use rustc_hir::{MethodKind, Target};
use rustc_span::{Symbol, sym};
use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::MaybeWarn::{Allow, Error};
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::session_diagnostics;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Error};
pub(crate) struct MustUseParser;
impl<S: Stage> SingleAttributeParser<S> for MustUseParser {

6
compiler/rustc_attr_parsing/src/attributes/no_implicit_prelude.rs
View file

@ -3,8 +3,10 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Span, sym};
use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
use crate::context::MaybeWarn::Allow;
use crate::context::{AllowedTargets, Stage};
use crate::context::Stage;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
pub(crate) struct NoImplicitPreludeParser;
impl<S: Stage> NoArgsAttributeParser<S> for NoImplicitPreludeParser {

6
compiler/rustc_attr_parsing/src/attributes/non_exhaustive.rs
View file

@ -3,8 +3,10 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Span, Symbol, sym};
use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
use crate::context::MaybeWarn::{Allow, Warn};
use crate::context::{AllowedTargets, Stage};
use crate::context::Stage;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Warn};
pub(crate) struct NonExhaustiveParser;
impl<S: Stage> NoArgsAttributeParser<S> for NonExhaustiveParser {

6
compiler/rustc_attr_parsing/src/attributes/path.rs
View file

@ -4,9 +4,11 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Symbol, sym};
use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::MaybeWarn::{Allow, Error};
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Error};
pub(crate) struct PathParser;
impl<S: Stage> SingleAttributeParser<S> for PathParser {

6
compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs
View file

@ -7,9 +7,11 @@ use thin_vec::ThinVec;
use crate::attributes::{
AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
};
use crate::context::MaybeWarn::{Allow, Warn};
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Warn};
pub(crate) struct ProcMacroParser;
impl<S: Stage> NoArgsAttributeParser<S> for ProcMacroParser {
const PATH: &[Symbol] = &[sym::proc_macro];

7
compiler/rustc_attr_parsing/src/attributes/prototype.rs
View file

@ -7,8 +7,10 @@ use rustc_span::{Span, Symbol, sym};
use super::{AttributeOrder, OnDuplicate};
use crate::attributes::SingleAttributeParser;
use crate::context::{AcceptContext, AllowedTargets, MaybeWarn, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
pub(crate) struct CustomMirParser;
@ -19,8 +21,7 @@ impl<S: Stage> SingleAttributeParser<S> for CustomMirParser {
const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
const ALLOWED_TARGETS: AllowedTargets =
AllowedTargets::AllowList(&[MaybeWarn::Allow(Target::Fn)]);
const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
const TEMPLATE: AttributeTemplate = template!(List: &[r#"dialect = "...", phase = "...""#]);

5
compiler/rustc_attr_parsing/src/attributes/repr.rs
View file

@ -6,11 +6,12 @@ use rustc_hir::{MethodKind, Target};
use rustc_span::{DUMMY_SP, Span, Symbol, sym};
use super::{AcceptMapping, AttributeParser, CombineAttributeParser, ConvertFn, FinalizeContext};
use crate::context::MaybeWarn::Allow;
use crate::context::{ALL_TARGETS, AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::{ArgParser, MetaItemListParser, MetaItemParser};
use crate::session_diagnostics;
use crate::session_diagnostics::IncorrectReprFormatGenericCause;
use crate::target_checking::Policy::Allow;
use crate::target_checking::{ALL_TARGETS, AllowedTargets};
/// Parse #[repr(...)] forms.
///
/// Valid repr contents: any of the primitive integral type names (see

8
compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
View file

@ -4,9 +4,13 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Symbol, sym};
use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::MaybeWarn::Allow;
use crate::context::{AcceptContext, AllowedTargets, Stage, parse_single_integer};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
use super::util::parse_single_integer;
pub(crate) struct RustcLayoutScalarValidRangeStart;
impl<S: Stage> SingleAttributeParser<S> for RustcLayoutScalarValidRangeStart {

4
compiler/rustc_attr_parsing/src/attributes/semantics.rs
View file

@ -2,7 +2,9 @@ use rustc_hir::attrs::AttributeKind;
use rustc_span::{Span, Symbol, sym};
use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
use crate::context::{ALL_TARGETS, AllowedTargets, Stage};
use crate::context::Stage;
use crate::target_checking::{ALL_TARGETS, AllowedTargets};
pub(crate) struct MayDangleParser;
impl<S: Stage> NoArgsAttributeParser<S> for MayDangleParser {
const PATH: &[Symbol] = &[sym::may_dangle];

5
compiler/rustc_attr_parsing/src/attributes/stability.rs
View file

@ -12,10 +12,11 @@ use rustc_span::{Ident, Span, Symbol, sym};
use super::util::parse_version;
use super::{AcceptMapping, AttributeParser, OnDuplicate};
use crate::attributes::NoArgsAttributeParser;
use crate::context::MaybeWarn::Allow;
use crate::context::{AcceptContext, AllowedTargets, FinalizeContext, Stage};
use crate::context::{AcceptContext, FinalizeContext, Stage};
use crate::parser::{ArgParser, MetaItemParser};
use crate::session_diagnostics::{self, UnsupportedLiteralReason};
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
macro_rules! reject_outside_std {
($cx: ident) => {

6
compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
View file

@ -5,9 +5,11 @@ use rustc_hir::lints::AttributeLintKind;
use rustc_span::{Symbol, sym};
use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::MaybeWarn::{Allow, Error};
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::{Allow, Error};
pub(crate) struct IgnoreParser;
impl<S: Stage> SingleAttributeParser<S> for IgnoreParser {

6
compiler/rustc_attr_parsing/src/attributes/traits.rs
View file

@ -8,9 +8,11 @@ use rustc_span::{Span, Symbol, sym};
use crate::attributes::{
AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
};
use crate::context::MaybeWarn::{Allow, Warn};
use crate::context::{ALL_TARGETS, AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::Policy::{Allow, Warn};
use crate::target_checking::{ALL_TARGETS, AllowedTargets};
pub(crate) struct SkipDuringMethodDispatchParser;
impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
const PATH: &[Symbol] = &[sym::rustc_skip_during_method_dispatch];

6
compiler/rustc_attr_parsing/src/attributes/transparency.rs
View file

@ -5,9 +5,11 @@ use rustc_span::hygiene::Transparency;
use rustc_span::{Symbol, sym};
use super::{AttributeOrder, OnDuplicate, SingleAttributeParser};
use crate::context::MaybeWarn::Allow;
use crate::context::{AcceptContext, AllowedTargets, Stage};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
use crate::target_checking::AllowedTargets;
use crate::target_checking::Policy::Allow;
pub(crate) struct TransparencyParser;
// FIXME(jdonszelmann): make these proper diagnostics

33
compiler/rustc_attr_parsing/src/attributes/util.rs
View file

@ -1,8 +1,12 @@
use rustc_ast::LitKind;
use rustc_ast::attr::{AttributeExt, first_attr_value_str_by_name};
use rustc_feature::is_builtin_attr_name;
use rustc_hir::RustcVersion;
use rustc_span::{Symbol, sym};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
/// Parse a rustc version number written inside string literal in an attribute,
/// like appears in `since = "1.0.0"`. Suffixes like "-dev" and "-nightly" are
/// not accepted in this position, unlike when parsing CFG_RELEASE.
@ -56,3 +60,32 @@ pub fn is_doc_alias_attrs_contain_symbol<'tcx, T: AttributeExt + 'tcx>(
}
false
}
/// Parse a single integer.
///
/// Used by attributes that take a single integer as argument, such as
/// `#[link_ordinal]` and `#[rustc_layout_scalar_valid_range_start]`.
/// `cx` is the context given to the attribute.
/// `args` is the parser for the attribute arguments.
pub(crate) fn parse_single_integer<S: Stage>(
cx: &mut AcceptContext<'_, '_, S>,
args: &ArgParser<'_>,
) -> Option<u128> {
let Some(list) = args.list() else {
cx.expected_list(cx.attr_span);
return None;
};
let Some(single) = list.single() else {
cx.expected_single_argument(list.span);
return None;
};
let Some(lit) = single.lit() else {
cx.expected_integer_literal(single.span());
return None;
};
let LitKind::Int(num, _ty) = lit.kind else {
cx.expected_integer_literal(single.span());
return None;
};
Some(num.0)
}

281
compiler/rustc_attr_parsing/src/context.rs
View file

@ -3,16 +3,13 @@ use std::collections::BTreeMap;
use std::ops::{Deref, DerefMut};
use std::sync::LazyLock;
use itertools::Itertools;
use private::Sealed;
use rustc_ast::{self as ast, AttrStyle, LitKind, MetaItemLit, NodeId};
use rustc_ast::{self as ast, AttrStyle, MetaItemLit, NodeId};
use rustc_errors::{DiagCtxtHandle, Diagnostic};
use rustc_feature::{AttributeTemplate, Features};
use rustc_hir::attrs::AttributeKind;
use rustc_hir::lints::{AttributeLint, AttributeLintKind};
use rustc_hir::{
AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId, HirId, MethodKind, Target,
};
use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId, HirId, Target};
use rustc_session::Session;
use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
@ -65,11 +62,9 @@ use crate::attributes::traits::{
};
use crate::attributes::transparency::TransparencyParser;
use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
use crate::context::MaybeWarn::{Allow, Error, Warn};
use crate::parser::{ArgParser, MetaItemParser, PathParser};
use crate::session_diagnostics::{
AttributeParseError, AttributeParseErrorReason, InvalidTarget, UnknownMetaItem,
};
use crate::session_diagnostics::{AttributeParseError, AttributeParseErrorReason, UnknownMetaItem};
use crate::target_checking::AllowedTargets;
type GroupType<S> = LazyLock<GroupTypeInner<S>>;
@ -667,69 +662,11 @@ impl ShouldEmit {
}
}
#[derive(Debug)]
pub(crate) enum AllowedTargets {
AllowList(&'static [MaybeWarn]),
AllowListWarnRest(&'static [MaybeWarn]),
}
pub(crate) enum AllowedResult {
Allowed,
Warn,
Error,
}
impl AllowedTargets {
pub(crate) fn is_allowed(&self, target: Target) -> AllowedResult {
match self {
AllowedTargets::AllowList(list) => {
if list.contains(&Allow(target)) {
AllowedResult::Allowed
} else if list.contains(&Warn(target)) {
AllowedResult::Warn
} else {
AllowedResult::Error
}
}
AllowedTargets::AllowListWarnRest(list) => {
if list.contains(&Allow(target)) {
AllowedResult::Allowed
} else if list.contains(&Error(target)) {
AllowedResult::Error
} else {
AllowedResult::Warn
}
}
}
}
pub(crate) fn allowed_targets(&self) -> Vec<Target> {
match self {
AllowedTargets::AllowList(list) => list,
AllowedTargets::AllowListWarnRest(list) => list,
}
.iter()
.filter_map(|target| match target {
Allow(target) => Some(*target),
Warn(_) => None,
Error(_) => None,
})
.collect()
}
}
#[derive(Debug, Eq, PartialEq)]
pub(crate) enum MaybeWarn {
Allow(Target),
Warn(Target),
Error(Target),
}
/// Context created once, for example as part of the ast lowering
/// context, through which all attributes can be lowered.
pub struct AttributeParser<'sess, S: Stage = Late> {
pub(crate) tools: Vec<Symbol>,
features: Option<&'sess Features>,
pub(crate) features: Option<&'sess Features>,
sess: &'sess Session,
stage: S,
@ -917,9 +854,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
let parser = MetaItemParser::from_attr(n, self.dcx());
let path = parser.path();
let args = parser.args();
let parts = path.segments().map(|i| i.name).collect::<Vec<_>>();
let path_parts = path.segments().map(|i| i.name).collect::<Vec<_>>();
if let Some(accepts) = S::parsers().accepters.get(parts.as_slice()) {
if let Some(accepts) = S::parsers().accepters.get(path_parts.as_slice()) {
for accept in accepts {
let mut cx: AcceptContext<'_, 'sess, S> = AcceptContext {
shared: SharedContext {
@ -937,44 +874,14 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
(accept.accept_fn)(&mut cx, args);
if self.stage.should_emit().should_emit() {
match accept.allowed_targets.is_allowed(target) {
AllowedResult::Allowed => {}
AllowedResult::Warn => {
let allowed_targets =
accept.allowed_targets.allowed_targets();
let (applied, only) = allowed_targets_applied(
allowed_targets,
target,
self.features,
);
emit_lint(AttributeLint {
id: target_id,
span: attr.span,
kind: AttributeLintKind::InvalidTarget {
name: parts[0],
target,
only: if only { "only " } else { "" },
applied,
},
});
}
AllowedResult::Error => {
let allowed_targets =
accept.allowed_targets.allowed_targets();
let (applied, only) = allowed_targets_applied(
allowed_targets,
target,
self.features,
);
self.dcx().emit_err(InvalidTarget {
span: attr.span,
name: parts[0],
target: target.plural_name(),
only: if only { "only " } else { "" },
applied,
});
}
}
self.check_target(
path.get_attribute_path(),
attr.span,
&accept.allowed_targets,
target,
target_id,
&mut emit_lint,
);
}
}
} else {
@ -1062,161 +969,3 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
}
}
}
/// Takes a list of `allowed_targets` for an attribute, and the `target` the attribute was applied to.
/// Does some heuristic-based filtering to remove uninteresting targets, and formats the targets into a string
pub(crate) fn allowed_targets_applied(
mut allowed_targets: Vec<Target>,
target: Target,
features: Option<&Features>,
) -> (String, bool) {
// Remove unstable targets from `allowed_targets` if their features are not enabled
if let Some(features) = features {
if !features.fn_delegation() {
allowed_targets.retain(|t| !matches!(t, Target::Delegation { .. }));
}
if !features.stmt_expr_attributes() {
allowed_targets.retain(|t| !matches!(t, Target::Expression | Target::Statement));
}
if !features.extern_types() {
allowed_targets.retain(|t| !matches!(t, Target::ForeignTy));
}
}
// We define groups of "similar" targets.
// If at least two of the targets are allowed, and the `target` is not in the group,
// we collapse the entire group to a single entry to simplify the target list
const FUNCTION_LIKE: &[Target] = &[
Target::Fn,
Target::Closure,
Target::ForeignFn,
Target::Method(MethodKind::Inherent),
Target::Method(MethodKind::Trait { body: false }),
Target::Method(MethodKind::Trait { body: true }),
Target::Method(MethodKind::TraitImpl),
];
const METHOD_LIKE: &[Target] = &[
Target::Method(MethodKind::Inherent),
Target::Method(MethodKind::Trait { body: false }),
Target::Method(MethodKind::Trait { body: true }),
Target::Method(MethodKind::TraitImpl),
];
const IMPL_LIKE: &[Target] =
&[Target::Impl { of_trait: false }, Target::Impl { of_trait: true }];
const ADT_LIKE: &[Target] = &[Target::Struct, Target::Enum];
let mut added_fake_targets = Vec::new();
filter_targets(
&mut allowed_targets,
FUNCTION_LIKE,
"functions",
target,
&mut added_fake_targets,
);
filter_targets(&mut allowed_targets, METHOD_LIKE, "methods", target, &mut added_fake_targets);
filter_targets(&mut allowed_targets, IMPL_LIKE, "impl blocks", target, &mut added_fake_targets);
filter_targets(&mut allowed_targets, ADT_LIKE, "data types", target, &mut added_fake_targets);
// If there is now only 1 target left, show that as the only possible target
(
added_fake_targets
.iter()
.copied()
.chain(allowed_targets.iter().map(|t| t.plural_name()))
.join(", "),
allowed_targets.len() + added_fake_targets.len() == 1,
)
}
fn filter_targets(
allowed_targets: &mut Vec<Target>,
target_group: &'static [Target],
target_group_name: &'static str,
target: Target,
added_fake_targets: &mut Vec<&'static str>,
) {
if target_group.contains(&target) {
return;
}
if allowed_targets.iter().filter(|at| target_group.contains(at)).count() < 2 {
return;
}
allowed_targets.retain(|t| !target_group.contains(t));
added_fake_targets.push(target_group_name);
}
/// This is the list of all targets to which a attribute can be applied
/// This is used for:
/// - `rustc_dummy`, which can be applied to all targets
/// - Attributes that are not parted to the new target system yet can use this list as a placeholder
pub(crate) const ALL_TARGETS: &'static [MaybeWarn] = &[
Allow(Target::ExternCrate),
Allow(Target::Use),
Allow(Target::Static),
Allow(Target::Const),
Allow(Target::Fn),
Allow(Target::Closure),
Allow(Target::Mod),
Allow(Target::ForeignMod),
Allow(Target::GlobalAsm),
Allow(Target::TyAlias),
Allow(Target::Enum),
Allow(Target::Variant),
Allow(Target::Struct),
Allow(Target::Field),
Allow(Target::Union),
Allow(Target::Trait),
Allow(Target::TraitAlias),
Allow(Target::Impl { of_trait: false }),
Allow(Target::Impl { of_trait: true }),
Allow(Target::Expression),
Allow(Target::Statement),
Allow(Target::Arm),
Allow(Target::AssocConst),
Allow(Target::Method(MethodKind::Inherent)),
Allow(Target::Method(MethodKind::Trait { body: false })),
Allow(Target::Method(MethodKind::Trait { body: true })),
Allow(Target::Method(MethodKind::TraitImpl)),
Allow(Target::AssocTy),
Allow(Target::ForeignFn),
Allow(Target::ForeignStatic),
Allow(Target::ForeignTy),
Allow(Target::MacroDef),
Allow(Target::Param),
Allow(Target::PatField),
Allow(Target::ExprField),
Allow(Target::WherePredicate),
Allow(Target::MacroCall),
Allow(Target::Crate),
Allow(Target::Delegation { mac: false }),
Allow(Target::Delegation { mac: true }),
];
/// Parse a single integer.
///
/// Used by attributes that take a single integer as argument, such as
/// `#[link_ordinal]` and `#[rustc_layout_scalar_valid_range_start]`.
/// `cx` is the context given to the attribute.
/// `args` is the parser for the attribute arguments.
pub(crate) fn parse_single_integer<S: Stage>(
cx: &mut AcceptContext<'_, '_, S>,
args: &ArgParser<'_>,
) -> Option<u128> {
let Some(list) = args.list() else {
cx.expected_list(cx.attr_span);
return None;
};
let Some(single) = list.single() else {
cx.expected_single_argument(list.span);
return None;
};
let Some(lit) = single.lit() else {
cx.expected_integer_literal(single.span());
return None;
};
let LitKind::Int(num, _ty) = lit.kind else {
cx.expected_integer_literal(single.span());
return None;
};
Some(num.0)
}

1
compiler/rustc_attr_parsing/src/lib.rs
View file

@ -89,6 +89,7 @@ pub(crate) mod context;
mod lints;
pub mod parser;
mod session_diagnostics;
mod target_checking;
pub use attributes::cfg::{CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg_attr};
pub use attributes::cfg_old::*;

12
compiler/rustc_attr_parsing/src/lints.rs
View file

@ -1,3 +1,5 @@
use std::borrow::Cow;
use rustc_errors::{DiagArgValue, LintEmitter};
use rustc_hir::lints::{AttributeLint, AttributeLintKind};
use rustc_hir::{HirId, Target};
@ -35,12 +37,12 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<HirId>, lint_emi
*first_span,
session_diagnostics::EmptyAttributeList { attr_span: *first_span },
),
&AttributeLintKind::InvalidTarget { name, target, ref applied, only } => lint_emitter
AttributeLintKind::InvalidTarget { name, target, applied, only } => lint_emitter
.emit_node_span_lint(
// This check is here because `deprecated` had its own lint group and removing this would be a breaking change
if name == sym::deprecated
if name.segments[0].name == sym::deprecated
&& ![Target::Closure, Target::Expression, Target::Statement, Target::Arm]
.contains(&target)
.contains(target)
{
rustc_session::lint::builtin::USELESS_DEPRECATED
} else {
@ -51,7 +53,9 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<HirId>, lint_emi
session_diagnostics::InvalidTargetLint {
name,
target: target.plural_name(),
applied: applied.clone(),
applied: DiagArgValue::StrListSepByAnd(
applied.into_iter().map(|i| Cow::Owned(i.to_string())).collect(),
),
only,
attr_span: *span,
},

12
compiler/rustc_attr_parsing/src/session_diagnostics.rs
View file

@ -484,10 +484,10 @@ pub(crate) struct EmptyAttributeList {
#[diag(attr_parsing_invalid_target_lint)]
#[warning]
#[help]
pub(crate) struct InvalidTargetLint {
pub name: Symbol,
pub target: &'static str,
pub applied: String,
pub(crate) struct InvalidTargetLint<'a> {
pub name: &'a AttrPath,
pub target: &'a str,
pub applied: DiagArgValue,
pub only: &'static str,
#[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
pub attr_span: Span,
@ -500,9 +500,9 @@ pub(crate) struct InvalidTarget {
#[primary_span]
#[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
pub span: Span,
pub name: Symbol,
pub name: AttrPath,
pub target: &'static str,
pub applied: String,
pub applied: DiagArgValue,
pub only: &'static str,
}

244
compiler/rustc_attr_parsing/src/target_checking.rs Normal file
View file

@ -0,0 +1,244 @@
use std::borrow::Cow;
use rustc_errors::DiagArgValue;
use rustc_feature::Features;
use rustc_hir::lints::{AttributeLint, AttributeLintKind};
use rustc_hir::{AttrPath, MethodKind, Target};
use rustc_span::Span;
use crate::AttributeParser;
use crate::context::Stage;
use crate::session_diagnostics::InvalidTarget;
#[derive(Debug)]
pub(crate) enum AllowedTargets {
AllowList(&'static [Policy]),
AllowListWarnRest(&'static [Policy]),
}
pub(crate) enum AllowedResult {
Allowed,
Warn,
Error,
}
impl AllowedTargets {
pub(crate) fn is_allowed(&self, target: Target) -> AllowedResult {
match self {
AllowedTargets::AllowList(list) => {
if list.contains(&Policy::Allow(target)) {
AllowedResult::Allowed
} else if list.contains(&Policy::Warn(target)) {
AllowedResult::Warn
} else {
AllowedResult::Error
}
}
AllowedTargets::AllowListWarnRest(list) => {
if list.contains(&Policy::Allow(target)) {
AllowedResult::Allowed
} else if list.contains(&Policy::Error(target)) {
AllowedResult::Error
} else {
AllowedResult::Warn
}
}
}
}
pub(crate) fn allowed_targets(&self) -> Vec<Target> {
match self {
AllowedTargets::AllowList(list) => list,
AllowedTargets::AllowListWarnRest(list) => list,
}
.iter()
.filter_map(|target| match target {
Policy::Allow(target) => Some(*target),
Policy::Warn(_) => None,
Policy::Error(_) => None,
})
.collect()
}
}
#[derive(Debug, Eq, PartialEq)]
pub(crate) enum Policy {
Allow(Target),
Warn(Target),
Error(Target),
}
impl<S: Stage> AttributeParser<'_, S> {
pub(crate) fn check_target(
&self,
attr_name: AttrPath,
attr_span: Span,
allowed_targets: &AllowedTargets,
target: Target,
target_id: S::Id,
mut emit_lint: impl FnMut(AttributeLint<S::Id>),
) {
match allowed_targets.is_allowed(target) {
AllowedResult::Allowed => {}
AllowedResult::Warn => {
let allowed_targets = allowed_targets.allowed_targets();
let (applied, only) =
allowed_targets_applied(allowed_targets, target, self.features);
emit_lint(AttributeLint {
id: target_id,
span: attr_span,
kind: AttributeLintKind::InvalidTarget {
name: attr_name,
target,
only: if only { "only " } else { "" },
applied,
},
});
}
AllowedResult::Error => {
let allowed_targets = allowed_targets.allowed_targets();
let (applied, only) =
allowed_targets_applied(allowed_targets, target, self.features);
self.dcx().emit_err(InvalidTarget {
span: attr_span,
name: attr_name,
target: target.plural_name(),
only: if only { "only " } else { "" },
applied: DiagArgValue::StrListSepByAnd(
applied.into_iter().map(Cow::Owned).collect(),
),
});
}
}
}
}
/// Takes a list of `allowed_targets` for an attribute, and the `target` the attribute was applied to.
/// Does some heuristic-based filtering to remove uninteresting targets, and formats the targets into a string
pub(crate) fn allowed_targets_applied(
mut allowed_targets: Vec<Target>,
target: Target,
features: Option<&Features>,
) -> (Vec<String>, bool) {
// Remove unstable targets from `allowed_targets` if their features are not enabled
if let Some(features) = features {
if !features.fn_delegation() {
allowed_targets.retain(|t| !matches!(t, Target::Delegation { .. }));
}
if !features.stmt_expr_attributes() {
allowed_targets.retain(|t| !matches!(t, Target::Expression | Target::Statement));
}
}
// We define groups of "similar" targets.
// If at least two of the targets are allowed, and the `target` is not in the group,
// we collapse the entire group to a single entry to simplify the target list
const FUNCTION_LIKE: &[Target] = &[
Target::Fn,
Target::Closure,
Target::ForeignFn,
Target::Method(MethodKind::Inherent),
Target::Method(MethodKind::Trait { body: false }),
Target::Method(MethodKind::Trait { body: true }),
Target::Method(MethodKind::TraitImpl),
];
const METHOD_LIKE: &[Target] = &[
Target::Method(MethodKind::Inherent),
Target::Method(MethodKind::Trait { body: false }),
Target::Method(MethodKind::Trait { body: true }),
Target::Method(MethodKind::TraitImpl),
];
const IMPL_LIKE: &[Target] =
&[Target::Impl { of_trait: false }, Target::Impl { of_trait: true }];
const ADT_LIKE: &[Target] = &[Target::Struct, Target::Enum];
let mut added_fake_targets = Vec::new();
filter_targets(
&mut allowed_targets,
FUNCTION_LIKE,
"functions",
target,
&mut added_fake_targets,
);
filter_targets(&mut allowed_targets, METHOD_LIKE, "methods", target, &mut added_fake_targets);
filter_targets(&mut allowed_targets, IMPL_LIKE, "impl blocks", target, &mut added_fake_targets);
filter_targets(&mut allowed_targets, ADT_LIKE, "data types", target, &mut added_fake_targets);
// If there is now only 1 target left, show that as the only possible target
(
added_fake_targets
.iter()
.copied()
.chain(allowed_targets.iter().map(|t| t.plural_name()))
.map(|i| i.to_string())
.collect(),
allowed_targets.len() + added_fake_targets.len() == 1,
)
}
fn filter_targets(
allowed_targets: &mut Vec<Target>,
target_group: &'static [Target],
target_group_name: &'static str,
target: Target,
added_fake_targets: &mut Vec<&'static str>,
) {
if target_group.contains(&target) {
return;
}
if allowed_targets.iter().filter(|at| target_group.contains(at)).count() < 2 {
return;
}
allowed_targets.retain(|t| !target_group.contains(t));
added_fake_targets.push(target_group_name);
}
/// This is the list of all targets to which a attribute can be applied
/// This is used for:
/// - `rustc_dummy`, which can be applied to all targets
/// - Attributes that are not parted to the new target system yet can use this list as a placeholder
pub(crate) const ALL_TARGETS: &'static [Policy] = {
use Policy::Allow;
&[
Allow(Target::ExternCrate),
Allow(Target::Use),
Allow(Target::Static),
Allow(Target::Const),
Allow(Target::Fn),
Allow(Target::Closure),
Allow(Target::Mod),
Allow(Target::ForeignMod),
Allow(Target::GlobalAsm),
Allow(Target::TyAlias),
Allow(Target::Enum),
Allow(Target::Variant),
Allow(Target::Struct),
Allow(Target::Field),
Allow(Target::Union),
Allow(Target::Trait),
Allow(Target::TraitAlias),
Allow(Target::Impl { of_trait: false }),
Allow(Target::Impl { of_trait: true }),
Allow(Target::Expression),
Allow(Target::Statement),
Allow(Target::Arm),
Allow(Target::AssocConst),
Allow(Target::Method(MethodKind::Inherent)),
Allow(Target::Method(MethodKind::Trait { body: false })),
Allow(Target::Method(MethodKind::Trait { body: true })),
Allow(Target::Method(MethodKind::TraitImpl)),
Allow(Target::AssocTy),
Allow(Target::ForeignFn),
Allow(Target::ForeignStatic),
Allow(Target::ForeignTy),
Allow(Target::MacroDef),
Allow(Target::Param),
Allow(Target::PatField),
Allow(Target::ExprField),
Allow(Target::WherePredicate),
Allow(Target::MacroCall),
Allow(Target::Crate),
Allow(Target::Delegation { mac: false }),
Allow(Target::Delegation { mac: true }),
]
};

6
compiler/rustc_hir/src/lints.rs
View file

@ -1,8 +1,8 @@
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_macros::HashStable_Generic;
use rustc_span::{Span, Symbol};
use rustc_span::Span;
use crate::{HirId, Target};
use crate::{AttrPath, HirId, Target};
#[derive(Debug)]
pub struct DelayedLints {
@ -34,5 +34,5 @@ pub enum AttributeLintKind {
UnusedDuplicate { this: Span, other: Span, warning: bool },
IllFormedAttributeInput { suggestions: Vec<String> },
EmptyAttribute { first_span: Span },
InvalidTarget { name: Symbol, target: Target, applied: String, only: &'static str },
InvalidTarget { name: AttrPath, target: Target, applied: Vec<String>, only: &'static str },
}

6
tests/ui/asm/naked-invalid-attr.stderr
View file

@ -18,7 +18,7 @@ error: `#[naked]` attribute cannot be used on foreign functions
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[naked]` can be applied to methods, functions
= help: `#[naked]` can be applied to methods and functions
error: `#[naked]` attribute cannot be used on structs
--> $DIR/naked-invalid-attr.rs:13:1
@ -42,7 +42,7 @@ error: `#[naked]` attribute cannot be used on required trait methods
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[naked]` can be applied to functions, inherent methods, provided trait methods, trait methods in impl blocks
= help: `#[naked]` can be applied to functions, inherent methods, provided trait methods, and trait methods in impl blocks
error: `#[naked]` attribute cannot be used on closures
--> $DIR/naked-invalid-attr.rs:51:5
@ -50,7 +50,7 @@ error: `#[naked]` attribute cannot be used on closures
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[naked]` can be applied to methods, functions
= help: `#[naked]` can be applied to methods and functions
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-invalid-attr.rs:56:3

12
tests/ui/attributes/linkage.stderr
View file

@ -4,7 +4,7 @@ error: `#[linkage]` attribute cannot be used on type aliases
LL | #[linkage = "weak"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[linkage]` can be applied to functions, statics, foreign statics
= help: `#[linkage]` can be applied to functions, statics, and foreign statics
error: `#[linkage]` attribute cannot be used on modules
--> $DIR/linkage.rs:9:1
@ -12,7 +12,7 @@ error: `#[linkage]` attribute cannot be used on modules
LL | #[linkage = "weak"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[linkage]` can be applied to functions, statics, foreign statics
= help: `#[linkage]` can be applied to functions, statics, and foreign statics
error: `#[linkage]` attribute cannot be used on structs
--> $DIR/linkage.rs:12:1
@ -20,7 +20,7 @@ error: `#[linkage]` attribute cannot be used on structs
LL | #[linkage = "weak"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[linkage]` can be applied to functions, statics, foreign statics
= help: `#[linkage]` can be applied to functions, statics, and foreign statics
error: `#[linkage]` attribute cannot be used on inherent impl blocks
--> $DIR/linkage.rs:15:1
@ -28,7 +28,7 @@ error: `#[linkage]` attribute cannot be used on inherent impl blocks
LL | #[linkage = "weak"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[linkage]` can be applied to functions, statics, foreign statics
= help: `#[linkage]` can be applied to functions, statics, and foreign statics
error: `#[linkage]` attribute cannot be used on expressions
--> $DIR/linkage.rs:23:5
@ -36,7 +36,7 @@ error: `#[linkage]` attribute cannot be used on expressions
LL | #[linkage = "weak"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[linkage]` can be applied to functions, statics, foreign statics
= help: `#[linkage]` can be applied to functions, statics, and foreign statics
error: `#[linkage]` attribute cannot be used on closures
--> $DIR/linkage.rs:39:13
@ -44,7 +44,7 @@ error: `#[linkage]` attribute cannot be used on closures
LL | let _ = #[linkage = "weak"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[linkage]` can be applied to methods, functions, statics, foreign statics, foreign functions
= help: `#[linkage]` can be applied to methods, functions, statics, foreign statics, and foreign functions
error: aborting due to 6 previous errors

34
tests/ui/coverage-attr/allowed-positions.stderr
View file

@ -14,7 +14,7 @@ error: `#[coverage]` attribute cannot be used on type aliases
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on traits
--> $DIR/allowed-positions.rs:17:1
@ -22,7 +22,7 @@ error: `#[coverage]` attribute cannot be used on traits
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on associated consts
--> $DIR/allowed-positions.rs:19:5
@ -30,7 +30,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on associated types
--> $DIR/allowed-positions.rs:22:5
@ -38,7 +38,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on required trait methods
--> $DIR/allowed-positions.rs:25:5
@ -46,7 +46,7 @@ error: `#[coverage]` attribute cannot be used on required trait methods
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to impl blocks, functions, closures, provided trait methods, trait methods in impl blocks, inherent methods, modules, crates
= help: `#[coverage]` can be applied to impl blocks, functions, closures, provided trait methods, trait methods in impl blocks, inherent methods, modules, and crates
error: `#[coverage]` attribute cannot be used on required trait methods
--> $DIR/allowed-positions.rs:31:5
@ -54,7 +54,7 @@ error: `#[coverage]` attribute cannot be used on required trait methods
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to impl blocks, functions, closures, provided trait methods, trait methods in impl blocks, inherent methods, modules, crates
= help: `#[coverage]` can be applied to impl blocks, functions, closures, provided trait methods, trait methods in impl blocks, inherent methods, modules, and crates
error: `#[coverage]` attribute cannot be used on associated types
--> $DIR/allowed-positions.rs:39:5
@ -62,7 +62,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on associated types
--> $DIR/allowed-positions.rs:56:5
@ -70,7 +70,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on structs
--> $DIR/allowed-positions.rs:61:1
@ -78,7 +78,7 @@ error: `#[coverage]` attribute cannot be used on structs
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on struct fields
--> $DIR/allowed-positions.rs:63:5
@ -86,7 +86,7 @@ error: `#[coverage]` attribute cannot be used on struct fields
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on foreign statics
--> $DIR/allowed-positions.rs:76:5
@ -94,7 +94,7 @@ error: `#[coverage]` attribute cannot be used on foreign statics
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on foreign types
--> $DIR/allowed-positions.rs:79:5
@ -102,7 +102,7 @@ error: `#[coverage]` attribute cannot be used on foreign types
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on foreign functions
--> $DIR/allowed-positions.rs:82:5
@ -110,7 +110,7 @@ error: `#[coverage]` attribute cannot be used on foreign functions
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to methods, impl blocks, functions, closures, modules, crates
= help: `#[coverage]` can be applied to methods, impl blocks, functions, closures, modules, and crates
error: `#[coverage]` attribute cannot be used on statements
--> $DIR/allowed-positions.rs:88:5
@ -118,7 +118,7 @@ error: `#[coverage]` attribute cannot be used on statements
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on statements
--> $DIR/allowed-positions.rs:94:5
@ -126,7 +126,7 @@ error: `#[coverage]` attribute cannot be used on statements
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on match arms
--> $DIR/allowed-positions.rs:110:9
@ -134,7 +134,7 @@ error: `#[coverage]` attribute cannot be used on match arms
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: `#[coverage]` attribute cannot be used on expressions
--> $DIR/allowed-positions.rs:114:5
@ -142,7 +142,7 @@ error: `#[coverage]` attribute cannot be used on expressions
LL | #[coverage(off)]
| ^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error: aborting due to 18 previous errors

14
tests/ui/coverage-attr/name-value.stderr
View file

@ -49,7 +49,7 @@ error: `#[coverage]` attribute cannot be used on structs
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:26:1
@ -87,7 +87,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:35:1
@ -110,7 +110,7 @@ error: `#[coverage]` attribute cannot be used on traits
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:39:5
@ -133,7 +133,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:44:5
@ -156,7 +156,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:50:1
@ -194,7 +194,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:58:5
@ -217,7 +217,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage = "off"]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/name-value.rs:64:1

14
tests/ui/coverage-attr/word-only.stderr
View file

@ -43,7 +43,7 @@ error: `#[coverage]` attribute cannot be used on structs
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:26:1
@ -77,7 +77,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:35:1
@ -98,7 +98,7 @@ error: `#[coverage]` attribute cannot be used on traits
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:39:5
@ -119,7 +119,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:44:5
@ -140,7 +140,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:50:1
@ -174,7 +174,7 @@ error: `#[coverage]` attribute cannot be used on associated consts
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:58:5
@ -195,7 +195,7 @@ error: `#[coverage]` attribute cannot be used on associated types
LL | #[coverage]
| ^^^^^^^^^^^
|
= help: `#[coverage]` can be applied to functions, impl blocks, modules, crates
= help: `#[coverage]` can be applied to functions, impl blocks, modules, and crates
error[E0539]: malformed `coverage` attribute input
--> $DIR/word-only.rs:64:1

2
tests/ui/deprecation/deprecation-sanity.stderr
View file

@ -177,7 +177,7 @@ LL | #[deprecated = "hello"]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, crates
= help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, foreign types, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
= note: `#[deny(useless_deprecated)]` on by default
error: aborting due to 10 previous errors

6
tests/ui/extern/extern-no-mangle.stderr vendored
View file

@ -5,7 +5,7 @@ LL | #[no_mangle]
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
note: the lint level is defined here
--> $DIR/extern-no-mangle.rs:1:9
|
@ -19,7 +19,7 @@ LL | #[no_mangle]
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to methods, functions, statics
= help: `#[no_mangle]` can be applied to methods, functions, and statics
warning: `#[no_mangle]` attribute cannot be used on statements
--> $DIR/extern-no-mangle.rs:24:5
@ -28,7 +28,7 @@ LL | #[no_mangle]
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
warning: 3 warnings emitted

6
tests/ui/extern/issue-47725.stderr vendored
View file

@ -13,7 +13,7 @@ LL | #[link_name = "foo"]
| ^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
note: the lint level is defined here
--> $DIR/issue-47725.rs:1:9
|
@ -27,7 +27,7 @@ LL | #[link_name = "foobar"]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on foreign modules
--> $DIR/issue-47725.rs:19:1
@ -36,7 +36,7 @@ LL | #[link_name]
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
error: aborting due to 1 previous error; 3 warnings emitted

2
tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
View file

@ -13,7 +13,7 @@ error: `#[allow_internal_unstable]` attribute cannot be used on structs
LL | #[allow_internal_unstable(something)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[allow_internal_unstable]` can be applied to macro defs, functions
= help: `#[allow_internal_unstable]` can be applied to macro defs and functions
error: aborting due to 2 previous errors

14
tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
View file

@ -30,7 +30,7 @@ error: `#[export_name]` attribute cannot be used on crates
LL | #![export_name = "2200"]
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to functions, statics
= help: `#[export_name]` can be applied to functions and statics
error: `#[inline]` attribute cannot be used on crates
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:28:1
@ -86,7 +86,7 @@ error: `#[export_name]` attribute cannot be used on modules
LL | #[export_name = "2200"]
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to functions, statics
= help: `#[export_name]` can be applied to functions and statics
error: `#[export_name]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:85:17
@ -94,7 +94,7 @@ error: `#[export_name]` attribute cannot be used on modules
LL | mod inner { #![export_name="2200"] }
| ^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to functions, statics
= help: `#[export_name]` can be applied to functions and statics
error: `#[export_name]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:90:5
@ -102,7 +102,7 @@ error: `#[export_name]` attribute cannot be used on structs
LL | #[export_name = "2200"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to functions, statics
= help: `#[export_name]` can be applied to functions and statics
error: `#[export_name]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:93:5
@ -110,7 +110,7 @@ error: `#[export_name]` attribute cannot be used on type aliases
LL | #[export_name = "2200"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to functions, statics
= help: `#[export_name]` can be applied to functions and statics
error: `#[export_name]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:96:5
@ -118,7 +118,7 @@ error: `#[export_name]` attribute cannot be used on inherent impl blocks
LL | #[export_name = "2200"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to functions, statics
= help: `#[export_name]` can be applied to functions and statics
error: `#[export_name]` attribute cannot be used on required trait methods
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:100:9
@ -126,7 +126,7 @@ error: `#[export_name]` attribute cannot be used on required trait methods
LL | #[export_name = "2200"] fn foo();
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[export_name]` can be applied to statics, functions, inherent methods, provided trait methods, trait methods in impl blocks
= help: `#[export_name]` can be applied to statics, functions, inherent methods, provided trait methods, and trait methods in impl blocks
error: attribute should be applied to an `extern crate` item
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:56:1

66
tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
View file

@ -675,7 +675,7 @@ LL | #[macro_use] fn f() { }
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
warning: `#[macro_use]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:197:5
@ -684,7 +684,7 @@ LL | #[macro_use] struct S;
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
warning: `#[macro_use]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:203:5
@ -693,7 +693,7 @@ LL | #[macro_use] type T = S;
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
warning: `#[macro_use]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:209:5
@ -702,7 +702,7 @@ LL | #[macro_use] impl S { }
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
warning: `#[path]` attribute cannot be used on functions
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:271:5
@ -810,7 +810,7 @@ LL | #[no_mangle]
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
warning: `#[no_mangle]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:347:17
@ -819,7 +819,7 @@ LL | mod inner { #![no_mangle] }
| ^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
warning: `#[no_mangle]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:355:5
@ -828,7 +828,7 @@ LL | #[no_mangle] struct S;
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
warning: `#[no_mangle]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:361:5
@ -837,7 +837,7 @@ LL | #[no_mangle] type T = S;
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
warning: `#[no_mangle]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:367:5
@ -846,7 +846,7 @@ LL | #[no_mangle] impl S { }
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics
= help: `#[no_mangle]` can be applied to functions and statics
warning: `#[no_mangle]` attribute cannot be used on required trait methods
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:374:9
@ -855,7 +855,7 @@ LL | #[no_mangle] fn foo();
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics, inherent methods, trait methods in impl blocks
= help: `#[no_mangle]` can be applied to functions, statics, inherent methods, and trait methods in impl blocks
warning: `#[no_mangle]` attribute cannot be used on provided trait methods
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:380:9
@ -864,7 +864,7 @@ LL | #[no_mangle] fn bar() {}
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_mangle]` can be applied to functions, statics, inherent methods, trait methods in impl blocks
= help: `#[no_mangle]` can be applied to functions, statics, inherent methods, and trait methods in impl blocks
warning: `#[should_panic]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:388:1
@ -963,7 +963,7 @@ LL | #[no_implicit_prelude] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_implicit_prelude]` can be applied to modules, crates
= help: `#[no_implicit_prelude]` can be applied to modules and crates
warning: `#[no_implicit_prelude]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:464:5
@ -972,7 +972,7 @@ LL | #[no_implicit_prelude] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_implicit_prelude]` can be applied to modules, crates
= help: `#[no_implicit_prelude]` can be applied to modules and crates
warning: `#[no_implicit_prelude]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:470:5
@ -981,7 +981,7 @@ LL | #[no_implicit_prelude] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_implicit_prelude]` can be applied to modules, crates
= help: `#[no_implicit_prelude]` can be applied to modules and crates
warning: `#[no_implicit_prelude]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:476:5
@ -990,7 +990,7 @@ LL | #[no_implicit_prelude] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[no_implicit_prelude]` can be applied to modules, crates
= help: `#[no_implicit_prelude]` can be applied to modules and crates
warning: `#[macro_escape]` attribute cannot be used on functions
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:510:5
@ -999,7 +999,7 @@ LL | #[macro_escape] fn f() { }
| ^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_escape]` can be applied to modules, extern crates, crates
= help: `#[macro_escape]` can be applied to modules, extern crates, and crates
warning: `#[macro_escape]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:516:5
@ -1008,7 +1008,7 @@ LL | #[macro_escape] struct S;
| ^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_escape]` can be applied to modules, extern crates, crates
= help: `#[macro_escape]` can be applied to modules, extern crates, and crates
warning: `#[macro_escape]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:522:5
@ -1017,7 +1017,7 @@ LL | #[macro_escape] type T = S;
| ^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_escape]` can be applied to modules, extern crates, crates
= help: `#[macro_escape]` can be applied to modules, extern crates, and crates
warning: `#[macro_escape]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:528:5
@ -1026,7 +1026,7 @@ LL | #[macro_escape] impl S { }
| ^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_escape]` can be applied to modules, extern crates, crates
= help: `#[macro_escape]` can be applied to modules, extern crates, and crates
warning: `#[cold]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:571:1
@ -1080,7 +1080,7 @@ LL | #[link_name = "1900"]
| ^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on foreign modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:611:5
@ -1089,7 +1089,7 @@ LL | #[link_name = "1900"]
| ^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:618:17
@ -1098,7 +1098,7 @@ LL | mod inner { #![link_name="1900"] }
| ^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on functions
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:624:5
@ -1107,7 +1107,7 @@ LL | #[link_name = "1900"] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:630:5
@ -1116,7 +1116,7 @@ LL | #[link_name = "1900"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:636:5
@ -1125,7 +1125,7 @@ LL | #[link_name = "1900"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_name]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:642:5
@ -1134,7 +1134,7 @@ LL | #[link_name = "1900"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_section]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:649:1
@ -1143,7 +1143,7 @@ LL | #[link_section = "1800"]
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_section]` can be applied to statics, functions
= help: `#[link_section]` can be applied to statics and functions
warning: `#[link_section]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:655:17
@ -1152,7 +1152,7 @@ LL | mod inner { #![link_section="1800"] }
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_section]` can be applied to statics, functions
= help: `#[link_section]` can be applied to statics and functions
warning: `#[link_section]` attribute cannot be used on structs
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:663:5
@ -1161,7 +1161,7 @@ LL | #[link_section = "1800"] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_section]` can be applied to statics, functions
= help: `#[link_section]` can be applied to statics and functions
warning: `#[link_section]` attribute cannot be used on type aliases
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:669:5
@ -1170,7 +1170,7 @@ LL | #[link_section = "1800"] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_section]` can be applied to statics, functions
= help: `#[link_section]` can be applied to statics and functions
warning: `#[link_section]` attribute cannot be used on inherent impl blocks
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:675:5
@ -1179,7 +1179,7 @@ LL | #[link_section = "1800"] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_section]` can be applied to statics, functions
= help: `#[link_section]` can be applied to statics and functions
warning: `#[must_use]` attribute cannot be used on modules
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:736:1
@ -1260,7 +1260,7 @@ LL | #![link_name = "1900"]
| ^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_name]` can be applied to foreign functions, foreign statics
= help: `#[link_name]` can be applied to foreign functions and foreign statics
warning: `#[link_section]` attribute cannot be used on crates
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:79:1
@ -1269,7 +1269,7 @@ LL | #![link_section = "1800"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[link_section]` can be applied to statics, functions
= help: `#[link_section]` can be applied to statics and functions
warning: `#[must_use]` attribute cannot be used on crates
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:84:1

6
tests/ui/linkage-attr/raw-dylib/windows/link-ordinal-not-foreign-fn.stderr
View file

@ -4,7 +4,7 @@ error: `#[link_ordinal]` attribute cannot be used on structs
LL | #[link_ordinal(123)]
| ^^^^^^^^^^^^^^^^^^^^
|
= help: `#[link_ordinal]` can be applied to foreign functions, foreign statics
= help: `#[link_ordinal]` can be applied to foreign functions and foreign statics
error: `#[link_ordinal]` attribute cannot be used on functions
--> $DIR/link-ordinal-not-foreign-fn.rs:5:1
@ -12,7 +12,7 @@ error: `#[link_ordinal]` attribute cannot be used on functions
LL | #[link_ordinal(123)]
| ^^^^^^^^^^^^^^^^^^^^
|
= help: `#[link_ordinal]` can be applied to foreign functions, foreign statics
= help: `#[link_ordinal]` can be applied to foreign functions and foreign statics
error: `#[link_ordinal]` attribute cannot be used on statics
--> $DIR/link-ordinal-not-foreign-fn.rs:9:1
@ -20,7 +20,7 @@ error: `#[link_ordinal]` attribute cannot be used on statics
LL | #[link_ordinal(42)]
| ^^^^^^^^^^^^^^^^^^^
|
= help: `#[link_ordinal]` can be applied to foreign functions, foreign statics
= help: `#[link_ordinal]` can be applied to foreign functions and foreign statics
error: aborting due to 3 previous errors

2
tests/ui/lint/unused/unused-attr-macro-rules.stderr
View file

@ -17,7 +17,7 @@ LL | #[macro_use]
| ^^^^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
error: `#[path]` attribute cannot be used on macro defs
--> $DIR/unused-attr-macro-rules.rs:9:1

4
tests/ui/lint/warn-unused-inline-on-fn-prototypes.stderr
View file

@ -5,7 +5,7 @@ LL | #[inline]
| ^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[inline]` can be applied to functions, inherent methods, provided trait methods, trait methods in impl blocks, closures
= help: `#[inline]` can be applied to functions, inherent methods, provided trait methods, trait methods in impl blocks, and closures
note: the lint level is defined here
--> $DIR/warn-unused-inline-on-fn-prototypes.rs:1:9
|
@ -19,7 +19,7 @@ LL | #[inline]
| ^^^^^^^^^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= help: `#[inline]` can be applied to methods, functions, closures
= help: `#[inline]` can be applied to methods, functions, and closures
error: aborting due to 2 previous errors

2
tests/ui/macros/issue-68060.stderr
View file

@ -4,7 +4,7 @@ error: `#[target_feature]` attribute cannot be used on closures
LL | #[target_feature(enable = "")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[target_feature]` can be applied to methods, functions
= help: `#[target_feature]` can be applied to methods and functions
error[E0658]: `#[track_caller]` on closures is currently unstable
--> $DIR/issue-68060.rs:6:13

4
tests/ui/rfcs/rfc-2008-non-exhaustive/invalid-attribute.stderr
View file

@ -13,7 +13,7 @@ error: `#[non_exhaustive]` attribute cannot be used on traits
LL | #[non_exhaustive]
| ^^^^^^^^^^^^^^^^^
|
= help: `#[non_exhaustive]` can be applied to data types, enum variants
= help: `#[non_exhaustive]` can be applied to data types and enum variants
error: `#[non_exhaustive]` attribute cannot be used on unions
--> $DIR/invalid-attribute.rs:9:1
@ -21,7 +21,7 @@ error: `#[non_exhaustive]` attribute cannot be used on unions
LL | #[non_exhaustive]
| ^^^^^^^^^^^^^^^^^
|
= help: `#[non_exhaustive]` can be applied to data types, enum variants
= help: `#[non_exhaustive]` can be applied to data types and enum variants
error: aborting due to 3 previous errors

2
tests/ui/target-feature/invalid-attribute.stderr
View file

@ -143,7 +143,7 @@ error: `#[target_feature]` attribute cannot be used on closures
LL | #[target_feature(enable = "sse2")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[target_feature]` can be applied to methods, functions
= help: `#[target_feature]` can be applied to methods and functions
error: cannot use `#[inline(always)]` with `#[target_feature]`
--> $DIR/invalid-attribute.rs:62:1

4
tests/ui/unstable-feature-bound/unstable_inherent_method.stderr
View file

@ -4,7 +4,7 @@ error: `#[unstable_feature_bound]` attribute cannot be used on required trait me
LL | #[unstable_feature_bound(foo)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[unstable_feature_bound]` can be applied to functions, trait impl blocks, traits
= help: `#[unstable_feature_bound]` can be applied to functions, trait impl blocks, and traits
error: `#[unstable_feature_bound]` attribute cannot be used on trait methods in impl blocks
--> $DIR/unstable_inherent_method.rs:18:5
@ -12,7 +12,7 @@ error: `#[unstable_feature_bound]` attribute cannot be used on trait methods in
LL | #[unstable_feature_bound(foo)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: `#[unstable_feature_bound]` can be applied to functions, trait impl blocks, traits
= help: `#[unstable_feature_bound]` can be applied to functions, trait impl blocks, and traits
error: aborting due to 2 previous errors

8
tests/ui/where-clauses/unsupported_attribute.stderr
View file

@ -48,7 +48,7 @@ error: `#[macro_use]` attribute cannot be used on where predicates
LL | #[macro_use] T: Trait,
| ^^^^^^^^^^^^
|
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
error: `#[macro_use]` attribute cannot be used on where predicates
--> $DIR/unsupported_attribute.rs:21:5
@ -56,7 +56,7 @@ error: `#[macro_use]` attribute cannot be used on where predicates
LL | #[macro_use] 'a: 'static,
| ^^^^^^^^^^^^
|
= help: `#[macro_use]` can be applied to modules, extern crates, crates
= help: `#[macro_use]` can be applied to modules, extern crates, and crates
error: `#[deprecated]` attribute cannot be used on where predicates
--> $DIR/unsupported_attribute.rs:24:5
@ -64,7 +64,7 @@ error: `#[deprecated]` attribute cannot be used on where predicates
LL | #[deprecated] T: Trait,
| ^^^^^^^^^^^^^
|
= help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, crates
= help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, foreign types, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
error: `#[deprecated]` attribute cannot be used on where predicates
--> $DIR/unsupported_attribute.rs:25:5
@ -72,7 +72,7 @@ error: `#[deprecated]` attribute cannot be used on where predicates
LL | #[deprecated] 'a: 'static,
| ^^^^^^^^^^^^^
|
= help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, crates
= help: `#[deprecated]` can be applied to functions, data types, modules, unions, constants, statics, macro defs, type aliases, use statements, foreign statics, foreign types, struct fields, traits, associated types, associated consts, enum variants, inherent impl blocks, and crates
error: `#[automatically_derived]` attribute cannot be used on where predicates
--> $DIR/unsupported_attribute.rs:26:5