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

Auto merge of #144556 - matthiaskrgr:rollup-aayo3h5, r=matthiaskrgr

Browse source 
Rollup of 6 pull requests

Successful merges:

 - rust-lang/rust#143607 (Port the proc macro attributes to the new attribute parsing infrastructure)
 - rust-lang/rust#144471 (Remove `compiler-builtins-{no-asm,mangled-names}`)
 - rust-lang/rust#144495 (bump cargo_metadata)
 - rust-lang/rust#144523 (rustdoc: save target modifiers)
 - rust-lang/rust#144534 (check_static_item: explain should_check_for_sync choices)
 - rust-lang/rust#144535 (miri: for ABI mismatch errors, say which argument is the problem)

Failed merges:

 - rust-lang/rust#144536 (miri subtree update)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2025-07-28 02:09:05 +00:00
commit 733dab5589
66 changed files with 656 additions and 479 deletions
Download patch file Download diff file Expand all files Collapse all files

18
Cargo.lock
View file

@ -441,20 +441,6 @@ dependencies = [
"thiserror 1.0.69",
]
[[package]]
name = "cargo_metadata"
version = "0.19.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
dependencies = [
"camino",
"cargo-platform 0.1.9",
"semver",
"serde",
"serde_json",
"thiserror 2.0.12",
]
[[package]]
name = "cargo_metadata"
version = "0.21.0"
@ -1364,7 +1350,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"askama",
"cargo_metadata 0.18.1",
"cargo_metadata 0.21.0",
"serde",
"serde_json",
"thiserror 1.0.69",
@ -5370,7 +5356,7 @@ name = "tidy"
version = "0.1.0"
dependencies = [
"build_helper",
"cargo_metadata 0.19.2",
"cargo_metadata 0.21.0",
"fluent-syntax",
"ignore",
"miropt-test-tools",

12
compiler/rustc_attr_data_structures/src/attributes.rs
View file

@ -416,12 +416,24 @@ pub enum AttributeKind {
/// Represents `#[pointee]`
Pointee(Span),
/// Represents `#[proc_macro]`
ProcMacro(Span),
/// Represents `#[proc_macro_attribute]`
ProcMacroAttribute(Span),
/// Represents `#[proc_macro_derive]`
ProcMacroDerive { trait_name: Symbol, helper_attrs: ThinVec<Symbol>, span: Span },
/// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
PubTransparent(Span),
/// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
Repr { reprs: ThinVec<(ReprAttr, Span)>, first_span: Span },
/// Represents `#[rustc_builtin_macro]`.
RustcBuiltinMacro { builtin_name: Option<Symbol>, helper_attrs: ThinVec<Symbol>, span: Span },
/// Represents `#[rustc_layout_scalar_valid_range_end]`.
RustcLayoutScalarValidRangeEnd(Box<u128>, Span),

4
compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
View file

@ -61,8 +61,12 @@ impl AttributeKind {
PassByValue(..) => Yes,
Path(..) => No,
Pointee(..) => No,
ProcMacro(..) => No,
ProcMacroAttribute(..) => No,
ProcMacroDerive { .. } => No,
PubTransparent(..) => Yes,
Repr { .. } => No,
RustcBuiltinMacro { .. } => Yes,
RustcLayoutScalarValidRangeEnd(..) => Yes,
RustcLayoutScalarValidRangeStart(..) => Yes,
RustcObjectLifetimeDefault => No,

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

@ -41,6 +41,7 @@ pub(crate) mod must_use;
pub(crate) mod no_implicit_prelude;
pub(crate) mod non_exhaustive;
pub(crate) mod path;
pub(crate) mod proc_macro_attrs;
pub(crate) mod repr;
pub(crate) mod rustc_internal;
pub(crate) mod semantics;

139
compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs Normal file
View file

@ -0,0 +1,139 @@
use rustc_attr_data_structures::AttributeKind;
use rustc_feature::{AttributeTemplate, template};
use rustc_span::{Span, Symbol, sym};
use thin_vec::ThinVec;
use crate::attributes::{
AttributeOrder, NoArgsAttributeParser, OnDuplicate, SingleAttributeParser,
};
use crate::context::{AcceptContext, Stage};
use crate::parser::ArgParser;
pub(crate) struct ProcMacroParser;
impl<S: Stage> NoArgsAttributeParser<S> for ProcMacroParser {
const PATH: &[Symbol] = &[sym::proc_macro];
const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
const CREATE: fn(Span) -> AttributeKind = AttributeKind::ProcMacro;
}
pub(crate) struct ProcMacroAttributeParser;
impl<S: Stage> NoArgsAttributeParser<S> for ProcMacroAttributeParser {
const PATH: &[Symbol] = &[sym::proc_macro_attribute];
const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
const CREATE: fn(Span) -> AttributeKind = AttributeKind::ProcMacroAttribute;
}
pub(crate) struct ProcMacroDeriveParser;
impl<S: Stage> SingleAttributeParser<S> for ProcMacroDeriveParser {
const PATH: &[Symbol] = &[sym::proc_macro_derive];
const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
const TEMPLATE: AttributeTemplate =
template!(List: "TraitName, /*opt*/ attributes(name1, name2, ...)");
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
let (trait_name, helper_attrs) = parse_derive_like(cx, args, true)?;
Some(AttributeKind::ProcMacroDerive {
trait_name: trait_name.expect("Trait name is mandatory, so it is present"),
helper_attrs,
span: cx.attr_span,
})
}
}
pub(crate) struct RustcBuiltinMacroParser;
impl<S: Stage> SingleAttributeParser<S> for RustcBuiltinMacroParser {
const PATH: &[Symbol] = &[sym::rustc_builtin_macro];
const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
const TEMPLATE: AttributeTemplate =
template!(List: "TraitName, /*opt*/ attributes(name1, name2, ...)");
fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
let (builtin_name, helper_attrs) = parse_derive_like(cx, args, false)?;
Some(AttributeKind::RustcBuiltinMacro { builtin_name, helper_attrs, span: cx.attr_span })
}
}
fn parse_derive_like<S: Stage>(
cx: &mut AcceptContext<'_, '_, S>,
args: &ArgParser<'_>,
trait_name_mandatory: bool,
) -> Option<(Option<Symbol>, ThinVec<Symbol>)> {
let Some(list) = args.list() else {
// For #[rustc_builtin_macro], it is permitted to leave out the trait name
if args.no_args().is_ok() && !trait_name_mandatory {
return Some((None, ThinVec::new()));
}
cx.expected_list(cx.attr_span);
return None;
};
let mut items = list.mixed();
// Parse the name of the trait that is derived.
let Some(trait_attr) = items.next() else {
cx.expected_at_least_one_argument(list.span);
return None;
};
let Some(trait_attr) = trait_attr.meta_item() else {
cx.unexpected_literal(trait_attr.span());
return None;
};
let Some(trait_ident) = trait_attr.path().word() else {
cx.expected_identifier(trait_attr.path().span());
return None;
};
if !trait_ident.name.can_be_raw() {
cx.expected_identifier(trait_ident.span);
return None;
}
if let Err(e) = trait_attr.args().no_args() {
cx.expected_no_args(e);
return None;
};
// Parse optional attributes
let mut attributes = ThinVec::new();
if let Some(attrs) = items.next() {
let Some(attr_list) = attrs.meta_item() else {
cx.expected_list(attrs.span());
return None;
};
if !attr_list.path().word_is(sym::attributes) {
cx.expected_specific_argument(attrs.span(), vec!["attributes"]);
return None;
}
let Some(attr_list) = attr_list.args().list() else {
cx.expected_list(attrs.span());
return None;
};
// Parse item in `attributes(...)` argument
for attr in attr_list.mixed() {
let Some(attr) = attr.meta_item() else {
cx.expected_identifier(attr.span());
return None;
};
if let Err(e) = attr.args().no_args() {
cx.expected_no_args(e);
return None;
};
let Some(ident) = attr.path().word() else {
cx.expected_identifier(attr.path().span());
return None;
};
if !ident.name.can_be_raw() {
cx.expected_identifier(ident.span);
return None;
}
attributes.push(ident.name);
}
}
// If anything else is specified, we should reject it
if let Some(next) = items.next() {
cx.expected_no_args(next.span());
}
Some((Some(trait_ident.name), attributes))
}

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

@ -38,6 +38,9 @@ use crate::attributes::must_use::MustUseParser;
use crate::attributes::no_implicit_prelude::NoImplicitPreludeParser;
use crate::attributes::non_exhaustive::NonExhaustiveParser;
use crate::attributes::path::PathParser as PathAttributeParser;
use crate::attributes::proc_macro_attrs::{
ProcMacroAttributeParser, ProcMacroDeriveParser, ProcMacroParser, RustcBuiltinMacroParser,
};
use crate::attributes::repr::{AlignParser, ReprParser};
use crate::attributes::rustc_internal::{
RustcLayoutScalarValidRangeEnd, RustcLayoutScalarValidRangeStart,
@ -154,6 +157,8 @@ attribute_parsers!(
Single<MustUseParser>,
Single<OptimizeParser>,
Single<PathAttributeParser>,
Single<ProcMacroDeriveParser>,
Single<RustcBuiltinMacroParser>,
Single<RustcForceInlineParser>,
Single<RustcLayoutScalarValidRangeEnd>,
Single<RustcLayoutScalarValidRangeStart>,
@ -186,6 +191,8 @@ attribute_parsers!(
Single<WithoutArgs<ParenSugarParser>>,
Single<WithoutArgs<PassByValueParser>>,
Single<WithoutArgs<PointeeParser>>,
Single<WithoutArgs<ProcMacroAttributeParser>>,
Single<WithoutArgs<ProcMacroParser>>,
Single<WithoutArgs<PubTransparentParser>>,
Single<WithoutArgs<SpecializationTraitParser>>,
Single<WithoutArgs<StdInternalSymbolParser>>,

28
compiler/rustc_builtin_macros/src/proc_macro_harness.rs
View file

@ -1,11 +1,13 @@
use std::mem;
use std::{mem, slice};
use rustc_ast::ptr::P;
use rustc_ast::visit::{self, Visitor};
use rustc_ast::{self as ast, NodeId, attr};
use rustc_ast::{self as ast, HasNodeId, NodeId, attr};
use rustc_ast_pretty::pprust;
use rustc_attr_data_structures::AttributeKind;
use rustc_attr_parsing::AttributeParser;
use rustc_errors::DiagCtxtHandle;
use rustc_expand::base::{ExtCtxt, ResolverExpand, parse_macro_name_and_helper_attrs};
use rustc_expand::base::{ExtCtxt, ResolverExpand};
use rustc_expand::expand::{AstFragment, ExpansionConfig};
use rustc_feature::Features;
use rustc_session::Session;
@ -22,7 +24,7 @@ struct ProcMacroDerive {
trait_name: Symbol,
function_ident: Ident,
span: Span,
attrs: Vec<Symbol>,
attrs: ThinVec<Symbol>,
}
struct ProcMacroDef {
@ -41,6 +43,7 @@ struct CollectProcMacros<'a> {
macros: Vec<ProcMacro>,
in_root: bool,
dcx: DiagCtxtHandle<'a>,
session: &'a Session,
source_map: &'a SourceMap,
is_proc_macro_crate: bool,
is_test_crate: bool,
@ -63,6 +66,7 @@ pub fn inject(
macros: Vec::new(),
in_root: true,
dcx,
session: sess,
source_map: sess.source_map(),
is_proc_macro_crate,
is_test_crate,
@ -98,8 +102,18 @@ impl<'a> CollectProcMacros<'a> {
function_ident: Ident,
attr: &'a ast::Attribute,
) {
let Some((trait_name, proc_attrs)) =
parse_macro_name_and_helper_attrs(self.dcx, attr, "derive")
let Some(rustc_hir::Attribute::Parsed(AttributeKind::ProcMacroDerive {
trait_name,
helper_attrs,
..
})) = AttributeParser::parse_limited(
self.session,
slice::from_ref(attr),
sym::proc_macro_derive,
item.span,
item.node_id(),
None,
)
else {
return;
};
@ -110,7 +124,7 @@ impl<'a> CollectProcMacros<'a> {
span: item.span,
trait_name,
function_ident,
attrs: proc_attrs,
attrs: helper_attrs,
}));
} else {
let msg = if !self.in_root {

6
compiler/rustc_const_eval/messages.ftl
View file

@ -128,15 +128,15 @@ const_eval_frame_note_inner = inside {$where_ ->
const_eval_frame_note_last = the failure occurred here
const_eval_incompatible_arg_types =
calling a function whose parameter #{$arg_idx} has type {$callee_ty} passing argument of type {$caller_ty}
const_eval_incompatible_calling_conventions =
calling a function with calling convention "{$callee_conv}" using calling convention "{$caller_conv}"
const_eval_incompatible_return_types =
calling a function with return type {$callee_ty} passing return place of type {$caller_ty}
const_eval_incompatible_types =
calling a function with argument of type {$callee_ty} passing data of type {$caller_ty}
const_eval_interior_mutable_borrow_escaping =
interior mutable shared borrows of temporaries that have their lifetime extended until the end of the program are not allowed
.label = this borrow of an interior mutable value refers to such a temporary

16
compiler/rustc_const_eval/src/errors.rs
View file

@ -500,7 +500,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
InvalidNichedEnumVariantWritten { .. } => {
const_eval_invalid_niched_enum_variant_written
}
AbiMismatchArgument { .. } => const_eval_incompatible_types,
AbiMismatchArgument { .. } => const_eval_incompatible_arg_types,
AbiMismatchReturn { .. } => const_eval_incompatible_return_types,
}
}
@ -625,12 +625,16 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
diag.arg("data_size", info.data_size);
}
InvalidNichedEnumVariantWritten { enum_ty } => {
diag.arg("ty", enum_ty.to_string());
diag.arg("ty", enum_ty);
}
AbiMismatchArgument { caller_ty, callee_ty }
| AbiMismatchReturn { caller_ty, callee_ty } => {
diag.arg("caller_ty", caller_ty.to_string());
diag.arg("callee_ty", callee_ty.to_string());
AbiMismatchArgument { arg_idx, caller_ty, callee_ty } => {
diag.arg("arg_idx", arg_idx + 1); // adjust for 1-indexed lists in output
diag.arg("caller_ty", caller_ty);
diag.arg("callee_ty", callee_ty);
}
AbiMismatchReturn { caller_ty, callee_ty } => {
diag.arg("caller_ty", caller_ty);
diag.arg("callee_ty", callee_ty);
}
}
}

10
compiler/rustc_const_eval/src/interpret/call.rs
View file

@ -270,6 +270,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
Item = (&'x FnArg<'tcx, M::Provenance>, &'y ArgAbi<'tcx, Ty<'tcx>>),
>,
callee_abi: &ArgAbi<'tcx, Ty<'tcx>>,
callee_arg_idx: usize,
callee_arg: &mir::Place<'tcx>,
callee_ty: Ty<'tcx>,
already_live: bool,
@ -298,6 +299,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
// Check compatibility
if !self.check_argument_compat(caller_abi, callee_abi)? {
throw_ub!(AbiMismatchArgument {
arg_idx: callee_arg_idx,
caller_ty: caller_abi.layout.ty,
callee_ty: callee_abi.layout.ty
});
@ -424,7 +426,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
// this is a single iterator (that handles `spread_arg`), then
// `pass_argument` would be the loop body. It takes care to
// not advance `caller_iter` for ignored arguments.
let mut callee_args_abis = callee_fn_abi.args.iter();
let mut callee_args_abis = callee_fn_abi.args.iter().enumerate();
for local in body.args_iter() {
// Construct the destination place for this argument. At this point all
// locals are still dead, so we cannot construct a `PlaceTy`.
@ -445,10 +447,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
&[mir::ProjectionElem::Field(FieldIdx::from_usize(i), field_ty)],
*self.tcx,
);
let callee_abi = callee_args_abis.next().unwrap();
let (idx, callee_abi) = callee_args_abis.next().unwrap();
self.pass_argument(
&mut caller_args,
callee_abi,
idx,
&dest,
field_ty,
/* already_live */ true,
@ -456,10 +459,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
}
} else {
// Normal argument. Cannot mark it as live yet, it might be unsized!
let callee_abi = callee_args_abis.next().unwrap();
let (idx, callee_abi) = callee_args_abis.next().unwrap();
self.pass_argument(
&mut caller_args,
callee_abi,
idx,
&dest,
ty,
/* already_live */ false,

27
compiler/rustc_expand/messages.ftl
View file

@ -1,26 +1,8 @@
expand_arg_not_attributes =
second argument must be `attributes`
expand_attr_no_arguments =
attribute must have either one or two arguments
expand_attribute_meta_item =
attribute must be a meta item, not a literal
expand_attribute_single_word =
attribute must only be a single word
expand_attributes_on_expressions_experimental =
attributes on expressions are experimental
.help_outer_doc = `///` is used for outer documentation comments; for a plain comment, use `//`
.help_inner_doc = `//!` is used for inner documentation comments; for a plain comment, use `//` by removing the `!` or inserting a space in between them: `// !`
expand_attributes_wrong_form =
attribute must be of form: `attributes(foo, bar)`
expand_cannot_be_name_of_macro =
`{$trait_ident}` cannot be a name of {$macro_type} macro
expand_collapse_debuginfo_illegal =
illegal value for attribute #[collapse_debuginfo(no|external|yes)]
@ -71,9 +53,6 @@ expand_glob_delegation_outside_impls =
expand_glob_delegation_traitless_qpath =
qualified path without a trait in glob delegation
expand_helper_attribute_name_invalid =
`{$name}` cannot be a name of derive helper attribute
expand_incomplete_parse =
macro expansion ignores {$descr} and any tokens following
.label = caused by the macro expansion here
@ -165,12 +144,6 @@ expand_mve_unrecognized_var =
expand_non_inline_modules_in_proc_macro_input_are_unstable =
non-inline modules in proc macro input are unstable
expand_not_a_meta_item =
not a meta item
expand_only_one_word =
must only be one word
expand_proc_macro_back_compat = using an old version of `{$crate_name}`
.note = older versions of the `{$crate_name}` crate no longer compile; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives

100
compiler/rustc_expand/src/base.rs
View file

@ -861,7 +861,7 @@ impl SyntaxExtension {
/// | (unspecified) | no | if-ext | if-ext | yes |
/// | external | no | if-ext | if-ext | yes |
/// | yes | yes | yes | yes | yes |
fn get_collapse_debuginfo(sess: &Session, attrs: &[impl AttributeExt], ext: bool) -> bool {
fn get_collapse_debuginfo(sess: &Session, attrs: &[hir::Attribute], ext: bool) -> bool {
let flag = sess.opts.cg.collapse_macro_debuginfo;
let attr = ast::attr::find_by_name(attrs, sym::collapse_debuginfo)
.and_then(|attr| {
@ -872,7 +872,7 @@ impl SyntaxExtension {
.ok()
})
.unwrap_or_else(|| {
if ast::attr::contains_name(attrs, sym::rustc_builtin_macro) {
if find_attr!(attrs, AttributeKind::RustcBuiltinMacro { .. }) {
CollapseMacroDebuginfo::Yes
} else {
CollapseMacroDebuginfo::Unspecified
@ -915,16 +915,18 @@ impl SyntaxExtension {
let collapse_debuginfo = Self::get_collapse_debuginfo(sess, attrs, !is_local);
tracing::debug!(?name, ?local_inner_macros, ?collapse_debuginfo, ?allow_internal_unsafe);
let (builtin_name, helper_attrs) = ast::attr::find_by_name(attrs, sym::rustc_builtin_macro)
.map(|attr| {
// Override `helper_attrs` passed above if it's a built-in macro,
// marking `proc_macro_derive` macros as built-in is not a realistic use case.
parse_macro_name_and_helper_attrs(sess.dcx(), attr, "built-in").map_or_else(
|| (Some(name), Vec::new()),
|(name, helper_attrs)| (Some(name), helper_attrs),
)
})
.unwrap_or_else(|| (None, helper_attrs));
let (builtin_name, helper_attrs) = match find_attr!(attrs, AttributeKind::RustcBuiltinMacro { builtin_name, helper_attrs, .. } => (builtin_name, helper_attrs))
{
// Override `helper_attrs` passed above if it's a built-in macro,
// marking `proc_macro_derive` macros as built-in is not a realistic use case.
Some((Some(name), helper_attrs)) => {
(Some(*name), helper_attrs.iter().copied().collect())
}
Some((None, _)) => (Some(name), Vec::new()),
// Not a built-in macro
None => (None, helper_attrs),
};
let stability = find_attr!(attrs, AttributeKind::Stability { stability, .. } => *stability);
@ -1390,80 +1392,6 @@ pub fn resolve_path(sess: &Session, path: impl Into<PathBuf>, span: Span) -> PRe
}
}
pub fn parse_macro_name_and_helper_attrs(
dcx: DiagCtxtHandle<'_>,
attr: &impl AttributeExt,
macro_type: &str,
) -> Option<(Symbol, Vec<Symbol>)> {
// Once we've located the `#[proc_macro_derive]` attribute, verify
// that it's of the form `#[proc_macro_derive(Foo)]` or
// `#[proc_macro_derive(Foo, attributes(A, ..))]`
let list = attr.meta_item_list()?;
let ([trait_attr] | [trait_attr, _]) = list.as_slice() else {
dcx.emit_err(errors::AttrNoArguments { span: attr.span() });
return None;
};
let Some(trait_attr) = trait_attr.meta_item() else {
dcx.emit_err(errors::NotAMetaItem { span: trait_attr.span() });
return None;
};
let trait_ident = match trait_attr.ident() {
Some(trait_ident) if trait_attr.is_word() => trait_ident,
_ => {
dcx.emit_err(errors::OnlyOneWord { span: trait_attr.span });
return None;
}
};
if !trait_ident.name.can_be_raw() {
dcx.emit_err(errors::CannotBeNameOfMacro {
span: trait_attr.span,
trait_ident,
macro_type,
});
}
let attributes_attr = list.get(1);
let proc_attrs: Vec<_> = if let Some(attr) = attributes_attr {
if !attr.has_name(sym::attributes) {
dcx.emit_err(errors::ArgumentNotAttributes { span: attr.span() });
}
attr.meta_item_list()
.unwrap_or_else(|| {
dcx.emit_err(errors::AttributesWrongForm { span: attr.span() });
&[]
})
.iter()
.filter_map(|attr| {
let Some(attr) = attr.meta_item() else {
dcx.emit_err(errors::AttributeMetaItem { span: attr.span() });
return None;
};
let ident = match attr.ident() {
Some(ident) if attr.is_word() => ident,
_ => {
dcx.emit_err(errors::AttributeSingleWord { span: attr.span });
return None;
}
};
if !ident.name.can_be_raw() {
dcx.emit_err(errors::HelperAttributeNameInvalid {
span: attr.span,
name: ident,
});
}
Some(ident.name)
})
.collect()
} else {
Vec::new()
};
Some((trait_ident.name, proc_attrs))
}
/// If this item looks like a specific enums from `rental`, emit a fatal error.
/// See #73345 and #83125 for more details.
/// FIXME(#73933): Remove this eventually.

66
compiler/rustc_expand/src/errors.rs
View file

@ -78,72 +78,6 @@ pub(crate) struct MacroBodyStability {
pub head_span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_attr_no_arguments)]
pub(crate) struct AttrNoArguments {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_not_a_meta_item)]
pub(crate) struct NotAMetaItem {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_only_one_word)]
pub(crate) struct OnlyOneWord {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_cannot_be_name_of_macro)]
pub(crate) struct CannotBeNameOfMacro<'a> {
#[primary_span]
pub span: Span,
pub trait_ident: Ident,
pub macro_type: &'a str,
}
#[derive(Diagnostic)]
#[diag(expand_arg_not_attributes)]
pub(crate) struct ArgumentNotAttributes {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_attributes_wrong_form)]
pub(crate) struct AttributesWrongForm {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_attribute_meta_item)]
pub(crate) struct AttributeMetaItem {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_attribute_single_word)]
pub(crate) struct AttributeSingleWord {
#[primary_span]
pub span: Span,
}
#[derive(Diagnostic)]
#[diag(expand_helper_attribute_name_invalid)]
pub(crate) struct HelperAttributeNameInvalid {
#[primary_span]
pub span: Span,
pub name: Ident,
}
#[derive(Diagnostic)]
#[diag(expand_feature_removed, code = E0557)]
#[note]

11
compiler/rustc_hir/src/hir.rs
View file

@ -1363,6 +1363,17 @@ impl AttributeExt for Attribute {
_ => None,
}
}
fn is_proc_macro_attr(&self) -> bool {
matches!(
self,
Attribute::Parsed(
AttributeKind::ProcMacro(..)
| AttributeKind::ProcMacroAttribute(..)
| AttributeKind::ProcMacroDerive { .. }
)
)
}
}
// FIXME(fn_delegation): use function delegation instead of manually forwarding

4
compiler/rustc_hir_analysis/src/check/check.rs
View file

@ -768,7 +768,9 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(),
check_static_inhabited(tcx, def_id);
check_static_linkage(tcx, def_id);
let ty = tcx.type_of(def_id).instantiate_identity();
res = res.and(wfcheck::check_static_item(tcx, def_id, ty, true));
res = res.and(wfcheck::check_static_item(
tcx, def_id, ty, /* should_check_for_sync */ true,
));
}
DefKind::Const => res = res.and(wfcheck::check_const_item(tcx, def_id)),
_ => unreachable!(),

8
compiler/rustc_hir_analysis/src/collect/type_of.rs
View file

@ -221,7 +221,9 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
let ty = icx.lower_ty(ty);
// MIR relies on references to statics being scalars.
// Verify that here to avoid ill-formed MIR.
match check_static_item(tcx, def_id, ty, false) {
// We skip the `Sync` check to avoid cycles for type-alias-impl-trait,
// relying on the fact that non-Sync statics don't ICE the rest of the compiler.
match check_static_item(tcx, def_id, ty, /* should_check_for_sync */ false) {
Ok(()) => ty,
Err(guar) => Ty::new_error(tcx, guar),
}
@ -286,7 +288,9 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
let ty = icx.lower_ty(ty);
// MIR relies on references to statics being scalars.
// Verify that here to avoid ill-formed MIR.
match check_static_item(tcx, def_id, ty, false) {
// We skip the `Sync` check to avoid cycles for type-alias-impl-trait,
// relying on the fact that non-Sync statics don't ICE the rest of the compiler.
match check_static_item(tcx, def_id, ty, /* should_check_for_sync */ false) {
Ok(()) => ty,
Err(guar) => Ty::new_error(tcx, guar),
}

17
compiler/rustc_metadata/src/rmeta/encoder.rs
View file

@ -5,7 +5,7 @@ use std::io::{Read, Seek, Write};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use rustc_attr_data_structures::EncodeCrossCrate;
use rustc_attr_data_structures::{AttributeKind, EncodeCrossCrate, find_attr};
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
use rustc_data_structures::memmap::{Mmap, MmapMut};
use rustc_data_structures::sync::{join, par_for_each_in};
@ -1965,18 +1965,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
// Proc-macros may have attributes like `#[allow_internal_unstable]`,
// so downstream crates need access to them.
let attrs = tcx.hir_attrs(proc_macro);
let macro_kind = if ast::attr::contains_name(attrs, sym::proc_macro) {
let macro_kind = if find_attr!(attrs, AttributeKind::ProcMacro(..)) {
MacroKind::Bang
} else if ast::attr::contains_name(attrs, sym::proc_macro_attribute) {
} else if find_attr!(attrs, AttributeKind::ProcMacroAttribute(..)) {
MacroKind::Attr
} else if let Some(attr) = ast::attr::find_by_name(attrs, sym::proc_macro_derive) {
// This unwrap chain should have been checked by the proc-macro harness.
name = attr.meta_item_list().unwrap()[0]
.meta_item()
.unwrap()
.ident()
.unwrap()
.name;
} else if let Some(trait_name) = find_attr!(attrs, AttributeKind::ProcMacroDerive { trait_name, ..} => trait_name)
{
name = *trait_name;
MacroKind::Derive
} else {
bug!("Unknown proc-macro type for item {:?}", id);

7
compiler/rustc_middle/src/mir/interpret/error.rs
View file

@ -426,7 +426,12 @@ pub enum UndefinedBehaviorInfo<'tcx> {
/// Trying to set discriminant to the niched variant, but the value does not match.
InvalidNichedEnumVariantWritten { enum_ty: Ty<'tcx> },
/// ABI-incompatible argument types.
AbiMismatchArgument { caller_ty: Ty<'tcx>, callee_ty: Ty<'tcx> },
AbiMismatchArgument {
/// The index of the argument whose type is wrong.
arg_idx: usize,
caller_ty: Ty<'tcx>,
callee_ty: Ty<'tcx>,
},
/// ABI-incompatible return types.
AbiMismatchReturn { caller_ty: Ty<'tcx>, callee_ty: Ty<'tcx> },
}

5
compiler/rustc_middle/src/ty/mod.rs
View file

@ -2024,7 +2024,10 @@ impl<'tcx> TyCtxt<'tcx> {
&& let Some(def_id) = def_id.as_local()
&& let outer = self.def_span(def_id).ctxt().outer_expn_data()
&& matches!(outer.kind, ExpnKind::Macro(MacroKind::Derive, _))
&& self.has_attr(outer.macro_def_id.unwrap(), sym::rustc_builtin_macro)
&& find_attr!(
self.get_all_attrs(outer.macro_def_id.unwrap()),
AttributeKind::RustcBuiltinMacro { .. }
)
{
true
} else {

27
compiler/rustc_passes/src/check_attr.rs
View file

@ -130,6 +130,22 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
for attr in attrs {
let mut style = None;
match attr {
Attribute::Parsed(AttributeKind::ProcMacro(_)) => {
self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike)
}
Attribute::Parsed(AttributeKind::ProcMacroAttribute(_)) => {
self.check_proc_macro(hir_id, target, ProcMacroKind::Attribute);
}
Attribute::Parsed(AttributeKind::ProcMacroDerive { span: attr_span, .. }) => {
self.check_generic_attr(
hir_id,
sym::proc_macro_derive,
*attr_span,
target,
Target::Fn,
);
self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
}
Attribute::Parsed(
AttributeKind::SkipDuringMethodDispatch { span: attr_span, .. }
| AttributeKind::Coinductive(attr_span)
@ -275,6 +291,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
| AttributeKind::MacroTransparency(_)
| AttributeKind::Pointee(..)
| AttributeKind::Dummy
| AttributeKind::RustcBuiltinMacro { .. }
| AttributeKind::OmitGdbPrettyPrinterSection,
) => { /* do nothing */ }
Attribute::Parsed(AttributeKind::AsPtr(attr_span)) => {
@ -373,16 +390,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
[sym::should_panic, ..] => {
self.check_generic_attr_unparsed(hir_id, attr, target, Target::Fn)
}
[sym::proc_macro, ..] => {
self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike)
}
[sym::proc_macro_attribute, ..] => {
self.check_proc_macro(hir_id, target, ProcMacroKind::Attribute);
}
[sym::proc_macro_derive, ..] => {
self.check_generic_attr_unparsed(hir_id, attr, target, Target::Fn);
self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
}
[sym::autodiff_forward, ..] | [sym::autodiff_reverse, ..] => {
self.check_autodiff(hir_id, attr, span, target)
}

2
library/alloc/Cargo.toml
View file

@ -21,9 +21,7 @@ compiler_builtins = { path = "../compiler-builtins/compiler-builtins", features
[features]
compiler-builtins-mem = ['compiler_builtins/mem']
compiler-builtins-c = ["compiler_builtins/c"]
compiler-builtins-no-asm = ["compiler_builtins/no-asm"]
compiler-builtins-no-f16-f128 = ["compiler_builtins/no-f16-f128"]
compiler-builtins-mangled-names = ["compiler_builtins/mangled-names"]
# Make panics and failed asserts immediately abort without formatting any message
panic_immediate_abort = ["core/panic_immediate_abort"]
# Choose algorithms that are optimized for binary size instead of runtime performance

2
library/std/Cargo.toml
View file

@ -97,9 +97,7 @@ backtrace-trace-only = []
panic-unwind = ["dep:panic_unwind"]
compiler-builtins-c = ["alloc/compiler-builtins-c"]
compiler-builtins-mem = ["alloc/compiler-builtins-mem"]
compiler-builtins-no-asm = ["alloc/compiler-builtins-no-asm"]
compiler-builtins-no-f16-f128 = ["alloc/compiler-builtins-no-f16-f128"]
compiler-builtins-mangled-names = ["alloc/compiler-builtins-mangled-names"]
llvm-libunwind = ["unwind/llvm-libunwind"]
system-llvm-libunwind = ["unwind/system-llvm-libunwind"]

2
library/sysroot/Cargo.toml
View file

@ -23,9 +23,7 @@ backtrace = ["std/backtrace"]
backtrace-trace-only = ["std/backtrace-trace-only"]
compiler-builtins-c = ["std/compiler-builtins-c"]
compiler-builtins-mem = ["std/compiler-builtins-mem"]
compiler-builtins-no-asm = ["std/compiler-builtins-no-asm"]
compiler-builtins-no-f16-f128 = ["std/compiler-builtins-no-f16-f128"]
compiler-builtins-mangled-names = ["std/compiler-builtins-mangled-names"]
debug_refcell = ["std/debug_refcell"]
llvm-libunwind = ["std/llvm-libunwind"]
system-llvm-libunwind = ["std/system-llvm-libunwind"]

51
src/librustdoc/clean/mod.rs
View file

@ -36,6 +36,7 @@ use std::mem;
use rustc_ast::token::{Token, TokenKind};
use rustc_ast::tokenstream::{TokenStream, TokenTree};
use rustc_attr_data_structures::{AttributeKind, find_attr};
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet, IndexEntry};
use rustc_errors::codes::*;
use rustc_errors::{FatalError, struct_span_code_err};
@ -987,28 +988,17 @@ fn clean_proc_macro<'tcx>(
kind: MacroKind,
cx: &mut DocContext<'tcx>,
) -> ItemKind {
if kind != MacroKind::Derive {
return ProcMacroItem(ProcMacro { kind, helpers: vec![] });
}
let attrs = cx.tcx.hir_attrs(item.hir_id());
if kind == MacroKind::Derive
&& let Some(derive_name) =
hir_attr_lists(attrs, sym::proc_macro_derive).find_map(|mi| mi.ident())
{
*name = derive_name.name;
}
let Some((trait_name, helper_attrs)) = find_attr!(attrs, AttributeKind::ProcMacroDerive { trait_name, helper_attrs, ..} => (*trait_name, helper_attrs))
else {
return ProcMacroItem(ProcMacro { kind, helpers: vec![] });
};
*name = trait_name;
let helpers = helper_attrs.iter().copied().collect();
let mut helpers = Vec::new();
for mi in hir_attr_lists(attrs, sym::proc_macro_derive) {
if !mi.has_name(sym::attributes) {
continue;
}
if let Some(list) = mi.meta_item_list() {
for inner_mi in list {
if let Some(ident) = inner_mi.ident() {
helpers.push(ident.name);
}
}
}
}
ProcMacroItem(ProcMacro { kind, helpers })
}
@ -1021,17 +1011,16 @@ fn clean_fn_or_proc_macro<'tcx>(
cx: &mut DocContext<'tcx>,
) -> ItemKind {
let attrs = cx.tcx.hir_attrs(item.hir_id());
let macro_kind = attrs.iter().find_map(|a| {
if a.has_name(sym::proc_macro) {
Some(MacroKind::Bang)
} else if a.has_name(sym::proc_macro_derive) {
Some(MacroKind::Derive)
} else if a.has_name(sym::proc_macro_attribute) {
Some(MacroKind::Attr)
} else {
None
}
});
let macro_kind = if find_attr!(attrs, AttributeKind::ProcMacro(..)) {
Some(MacroKind::Bang)
} else if find_attr!(attrs, AttributeKind::ProcMacroDerive { .. }) {
Some(MacroKind::Derive)
} else if find_attr!(attrs, AttributeKind::ProcMacroAttribute(..)) {
Some(MacroKind::Attr)
} else {
None
};
match macro_kind {
Some(kind) => clean_proc_macro(item, name, kind, cx),
None => {

4
src/librustdoc/config.rs
View file

@ -173,6 +173,9 @@ pub(crate) struct Options {
/// Arguments to be used when compiling doctests.
pub(crate) doctest_build_args: Vec<String>,
/// Target modifiers.
pub(crate) target_modifiers: BTreeMap<OptionsTargetModifiers, String>,
}
impl fmt::Debug for Options {
@ -846,6 +849,7 @@ impl Options {
unstable_features,
expanded_args: args,
doctest_build_args,
target_modifiers,
};
let render_options = RenderOptions {
output,

2
src/librustdoc/core.rs
View file

@ -214,6 +214,7 @@ pub(crate) fn create_config(
scrape_examples_options,
expanded_args,
remap_path_prefix,
target_modifiers,
..
}: RustdocOptions,
render_options: &RenderOptions,
@ -277,6 +278,7 @@ pub(crate) fn create_config(
} else {
OutputTypes::new(&[])
},
target_modifiers,
..Options::default()
};

4
src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
View file

@ -312,9 +312,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
/// Functions marked with these attributes must have the exact signature.
pub(crate) fn requires_exact_signature(attrs: &[Attribute]) -> bool {
attrs.iter().any(|attr| {
[sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
.iter()
.any(|&allow| attr.has_name(allow))
attr.is_proc_macro_attr()
})
}

2
src/tools/generate-copyright/Cargo.toml
View file

@ -9,7 +9,7 @@ description = "Produces a manifest of all the copyrighted materials in the Rust
[dependencies]
anyhow = "1.0.65"
askama = "0.14.0"
cargo_metadata = "0.18.1"
cargo_metadata = "0.21"
serde = { version = "1.0.147", features = ["derive"] }
serde_json = "1.0.85"
thiserror = "1"

3
src/tools/generate-copyright/src/cargo_metadata.rs
View file

@ -92,7 +92,8 @@ pub fn get_metadata(
continue;
}
// otherwise it's an out-of-tree dependency
let package_id = Package { name: package.name, version: package.version.to_string() };
let package_id =
Package { name: package.name.to_string(), version: package.version.to_string() };
output.insert(
package_id,
PackageMetadata {

2
src/tools/miri/src/diagnostics.rs
View file

@ -382,7 +382,7 @@ pub fn report_error<'tcx>(
helps.push(note_span!(span, "{:?} was deallocated here:", alloc_id));
}
}
AbiMismatchArgument { .. } | AbiMismatchReturn { .. } => {
AbiMismatchArgument { .. } => {
helps.push(note!("this means these two types are not *guaranteed* to be ABI-compatible across all targets"));
helps.push(note!("if you think this code should be accepted anyway, please report an issue with Miri"));
}

1
src/tools/miri/src/helpers.rs
View file

@ -1079,6 +1079,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
.position(|b| !b)
{
throw_ub!(AbiMismatchArgument {
arg_idx: index,
caller_ty: caller_fn_abi.args[index].layout.ty,
callee_ty: callee_fn_abi.args[index].layout.ty
});

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs
View file

@ -17,5 +17,5 @@ fn main() {
// These two types have the same size but are still not compatible.
let g = unsafe { std::mem::transmute::<fn(S), fn(A)>(f) };
g(Default::default()) //~ ERROR: calling a function with argument of type S passing data of type [i32; 4]
g(Default::default()) //~ ERROR: type S passing argument of type [i32; 4]
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_array_vs_struct.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type S passing data of type [i32; 4]
error: Undefined Behavior: calling a function whose parameter #1 has type S passing argument of type [i32; 4]
--> tests/fail/function_pointers/abi_mismatch_array_vs_struct.rs:LL:CC
|
LL | g(Default::default())

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.rs
View file

@ -3,5 +3,5 @@ fn main() {
let g = unsafe { std::mem::transmute::<fn(f32), fn(i32)>(f) };
g(42) //~ ERROR: calling a function with argument of type f32 passing data of type i32
g(42) //~ ERROR: type f32 passing argument of type i32
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_int_vs_float.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type f32 passing data of type i32
error: Undefined Behavior: calling a function whose parameter #1 has type f32 passing argument of type i32
--> tests/fail/function_pointers/abi_mismatch_int_vs_float.rs:LL:CC
|
LL | g(42)

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.rs
View file

@ -3,5 +3,5 @@ fn main() {
let g = unsafe { std::mem::transmute::<fn(*const [i32]), fn(*const i32)>(f) };
g(&42 as *const i32) //~ ERROR: calling a function with argument of type *const [i32] passing data of type *const i32
g(&42 as *const i32) //~ ERROR: type *const [i32] passing argument of type *const i32
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_raw_pointer.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type *const [i32] passing data of type *const i32
error: Undefined Behavior: calling a function whose parameter #1 has type *const [i32] passing argument of type *const i32
--> tests/fail/function_pointers/abi_mismatch_raw_pointer.rs:LL:CC
|
LL | g(&42 as *const i32)

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
View file

@ -12,5 +12,5 @@ fn main() {
let fnptr: fn(S2) = callee;
let fnptr: fn(S1) = unsafe { std::mem::transmute(fnptr) };
fnptr(S1(NonZero::new(1).unwrap()));
//~^ ERROR: calling a function with argument of type S2 passing data of type S1
//~^ ERROR: type S2 passing argument of type S1
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type S2 passing data of type S1
error: Undefined Behavior: calling a function whose parameter #1 has type S2 passing argument of type S1
--> tests/fail/function_pointers/abi_mismatch_repr_C.rs:LL:CC
|
LL | fnptr(S1(NonZero::new(1).unwrap()));

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.rs
View file

@ -5,5 +5,5 @@ fn main() {
let g = unsafe { std::mem::transmute::<fn() -> u32, fn()>(f) };
g() //~ ERROR: calling a function with return type u32 passing return place of type ()
g() //~ ERROR: type u32 passing return place of type ()
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_return_type.stderr
View file

@ -6,8 +6,6 @@ LL | g()
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
= help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
= help: if you think this code should be accepted anyway, please report an issue with Miri
= note: BACKTRACE:
= note: inside `main` at tests/fail/function_pointers/abi_mismatch_return_type.rs:LL:CC

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.rs
View file

@ -3,5 +3,5 @@ fn main() {
let g = unsafe { std::mem::transmute::<fn((i32, i32)), fn(i32)>(f) };
g(42) //~ ERROR: calling a function with argument of type (i32, i32) passing data of type i32
g(42) //~ ERROR: type (i32, i32) passing argument of type i32
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_simple.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type (i32, i32) passing data of type i32
error: Undefined Behavior: calling a function whose parameter #1 has type (i32, i32) passing argument of type i32
--> tests/fail/function_pointers/abi_mismatch_simple.rs:LL:CC
|
LL | g(42)

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.rs
View file

@ -7,5 +7,5 @@ fn main() {
// These two vector types have the same size but are still not compatible.
let g = unsafe { std::mem::transmute::<fn(simd::u32x8), fn(simd::u64x4)>(f) };
g(Default::default()) //~ ERROR: calling a function with argument of type std::simd::Simd<u32, 8> passing data of type std::simd::Simd<u64, 4>
g(Default::default()) //~ ERROR: type std::simd::Simd<u32, 8> passing argument of type std::simd::Simd<u64, 4>
}

2
src/tools/miri/tests/fail/function_pointers/abi_mismatch_vector.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type std::simd::Simd<u32, 8> passing data of type std::simd::Simd<u64, 4>
error: Undefined Behavior: calling a function whose parameter #1 has type std::simd::Simd<u32, 8> passing argument of type std::simd::Simd<u64, 4>
--> tests/fail/function_pointers/abi_mismatch_vector.rs:LL:CC
|
LL | g(Default::default())

2
src/tools/miri/tests/fail/shims/input_arg_mismatch.rs
View file

@ -16,6 +16,6 @@ fn main() {
} as u32;
let _ = unsafe {
close(fd);
//~^ ERROR: calling a function with argument of type i32 passing data of type u32
//~^ ERROR: type i32 passing argument of type u32
};
}

2
src/tools/miri/tests/fail/shims/input_arg_mismatch.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type i32 passing data of type u32
error: Undefined Behavior: calling a function whose parameter #1 has type i32 passing argument of type u32
--> tests/fail/shims/input_arg_mismatch.rs:LL:CC
|
LL | close(fd);

2
src/tools/miri/tests/fail/shims/return_type_mismatch.stderr
View file

@ -6,8 +6,6 @@ LL | close(fd);
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
= help: this means these two types are not *guaranteed* to be ABI-compatible across all targets
= help: if you think this code should be accepted anyway, please report an issue with Miri
= note: BACKTRACE:
= note: inside `main` at tests/fail/shims/return_type_mismatch.rs:LL:CC

2
src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.rs
View file

@ -6,7 +6,7 @@ fn main() {
// the error should point to `become g(x)`,
// but tail calls mess up the backtrace it seems like...
f(0);
//~^ error: Undefined Behavior: calling a function with argument of type i32 passing data of type u32
//~^ error: type i32 passing argument of type u32
}
fn f(x: u32) {

2
src/tools/miri/tests/fail/tail_calls/signature-mismatch-arg.stderr
View file

@ -1,4 +1,4 @@
error: Undefined Behavior: calling a function with argument of type i32 passing data of type u32
error: Undefined Behavior: calling a function whose parameter #1 has type i32 passing argument of type u32
--> tests/fail/tail_calls/signature-mismatch-arg.rs:LL:CC
|
LL | f(0);

2
src/tools/tidy/Cargo.toml
View file

@ -6,7 +6,7 @@ autobins = false
[dependencies]
build_helper = { path = "../../build_helper" }
cargo_metadata = "0.19"
cargo_metadata = "0.21"
regex = "1"
miropt-test-tools = { path = "../miropt-test-tools" }
walkdir = "2"

16
src/tools/tidy/src/deps.rs
View file

@ -633,8 +633,8 @@ fn check_proc_macro_dep_list(root: &Path, cargo: &Path, bless: bool, bad: &mut b
proc_macro_deps.retain(|pkg| !is_proc_macro_pkg(&metadata[pkg]));
let proc_macro_deps: HashSet<_> =
proc_macro_deps.into_iter().map(|dep| metadata[dep].name.clone()).collect();
let expected = proc_macro_deps::CRATES.iter().map(|s| s.to_string()).collect::<HashSet<_>>();
proc_macro_deps.into_iter().map(|dep| metadata[dep].name.as_ref()).collect();
let expected = proc_macro_deps::CRATES.iter().copied().collect::<HashSet<_>>();
let needs_blessing = proc_macro_deps.difference(&expected).next().is_some()
|| expected.difference(&proc_macro_deps).next().is_some();
@ -718,7 +718,7 @@ fn check_runtime_license_exceptions(metadata: &Metadata, bad: &mut bool) {
// See https://github.com/rust-lang/rust/issues/62620 for more.
// In general, these should never be added and this exception
// should not be taken as precedent for any new target.
if pkg.name == "fortanix-sgx-abi" && pkg.license.as_deref() == Some("MPL-2.0") {
if *pkg.name == "fortanix-sgx-abi" && pkg.license.as_deref() == Some("MPL-2.0") {
continue;
}
@ -734,7 +734,7 @@ fn check_license_exceptions(metadata: &Metadata, exceptions: &[(&str, &str)], ba
// Validate the EXCEPTIONS list hasn't changed.
for (name, license) in exceptions {
// Check that the package actually exists.
if !metadata.packages.iter().any(|p| p.name == *name) {
if !metadata.packages.iter().any(|p| *p.name == *name) {
tidy_error!(
bad,
"could not find exception package `{}`\n\
@ -743,7 +743,7 @@ fn check_license_exceptions(metadata: &Metadata, exceptions: &[(&str, &str)], ba
);
}
// Check that the license hasn't changed.
for pkg in metadata.packages.iter().filter(|p| p.name == *name) {
for pkg in metadata.packages.iter().filter(|p| *p.name == *name) {
match &pkg.license {
None => {
if *license == NON_STANDARD_LICENSE
@ -818,9 +818,9 @@ fn check_permitted_dependencies(
let Ok(version) = Version::parse(version) else {
return false;
};
pkg.name == name && pkg.version == version
*pkg.name == name && pkg.version == version
} else {
pkg.name == permitted
*pkg.name == permitted
}
}
if !deps.iter().any(|dep_id| compare(pkg_from_id(metadata, dep_id), permitted)) {
@ -868,7 +868,7 @@ fn check_permitted_dependencies(
/// Finds a package with the given name.
fn pkg_from_name<'a>(metadata: &'a Metadata, name: &'static str) -> &'a Package {
let mut i = metadata.packages.iter().filter(|p| p.name == name);
let mut i = metadata.packages.iter().filter(|p| *p.name == name);
let result =
i.next().unwrap_or_else(|| panic!("could not find package `{name}` in package list"));
assert!(i.next().is_none(), "more than one package found for `{name}`");

7
tests/run-make/rustdoc-target-modifiers/c.rs Normal file
View file

@ -0,0 +1,7 @@
#![allow(internal_features)]
#![feature(lang_items, no_core)]
#![no_core]
fn f() {
d::f();
}

12
tests/run-make/rustdoc-target-modifiers/d.rs Normal file
View file

@ -0,0 +1,12 @@
#![allow(internal_features)]
#![feature(lang_items, no_core)]
#![no_core]
#[lang = "pointee_sized"]
pub trait PointeeSized {}
#[lang = "meta_sized"]
pub trait MetaSized: PointeeSized {}
#[lang = "sized"]
pub trait Sized: MetaSized {}
pub fn f() {}

28
tests/run-make/rustdoc-target-modifiers/rmake.rs Normal file
View file

@ -0,0 +1,28 @@
//! Test that target modifiers are taken into account by `rustdoc`.
//!
//! Otherwise, `rustdoc` errors when trying to generate documentation
//! using dependencies (e.g. `core`) that set a target modifier.
//!
//! Please see https://github.com/rust-lang/rust/issues/144521.
use run_make_support::{rustc, rustdoc};
fn main() {
rustc()
.input("d.rs")
.edition("2024")
.crate_type("rlib")
.emit("metadata")
.sysroot("/dev/null")
.target("aarch64-unknown-none-softfloat")
.arg("-Zfixed-x18")
.run();
rustdoc()
.input("c.rs")
.crate_type("rlib")
.extern_("d", "libd.rmeta")
.target("aarch64-unknown-none-softfloat")
.arg("-Zfixed-x18")
.run();
}

45
tests/ui/attributes/malformed-attrs.stderr
View file

@ -43,12 +43,6 @@ error: malformed `no_sanitize` attribute input
LL | #[no_sanitize]
| ^^^^^^^^^^^^^^ help: must be of the form: `#[no_sanitize(address, kcfi, memory, thread)]`
error: malformed `proc_macro` attribute input
--> $DIR/malformed-attrs.rs:100:1
|
LL | #[proc_macro = 18]
| ^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro]`
error: malformed `instruction_set` attribute input
--> $DIR/malformed-attrs.rs:107:1
|
@ -67,18 +61,6 @@ error: malformed `coroutine` attribute input
LL | #[coroutine = 63] || {}
| ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[coroutine]`
error: malformed `proc_macro_attribute` attribute input
--> $DIR/malformed-attrs.rs:117:1
|
LL | #[proc_macro_attribute = 19]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_attribute]`
error: malformed `proc_macro_derive` attribute input
--> $DIR/malformed-attrs.rs:124:1
|
LL | #[proc_macro_derive]
| ^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: malformed `must_not_suspend` attribute input
--> $DIR/malformed-attrs.rs:133:1
|
@ -454,6 +436,24 @@ LL | #[no_implicit_prelude = 23]
| | didn't expect any arguments here
| help: must be of the form: `#[no_implicit_prelude]`
error[E0565]: malformed `proc_macro` attribute input
--> $DIR/malformed-attrs.rs:100:1
|
LL | #[proc_macro = 18]
| ^^^^^^^^^^^^^----^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro]`
error[E0565]: malformed `proc_macro_attribute` attribute input
--> $DIR/malformed-attrs.rs:117:1
|
LL | #[proc_macro_attribute = 19]
| ^^^^^^^^^^^^^^^^^^^^^^^----^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_attribute]`
error[E0539]: malformed `must_use` attribute input
--> $DIR/malformed-attrs.rs:120:1
|
@ -471,6 +471,15 @@ LL - #[must_use = 1]
LL + #[must_use]
|
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/malformed-attrs.rs:124:1
|
LL | #[proc_macro_derive]
| ^^^^^^^^^^^^^^^^^^^^
| |
| expected this to be a list
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error[E0539]: malformed `rustc_layout_scalar_valid_range_start` attribute input
--> $DIR/malformed-attrs.rs:129:1
|

1
tests/ui/attributes/unsafe/proc-unsafe-attributes.rs
View file

@ -12,6 +12,7 @@ pub fn b() {}
#[proc_macro_derive(unsafe(Foo))]
//~^ ERROR attribute is only usable with crates of the `proc-macro` crate type
//~| ERROR: expected identifier, found keyword `unsafe`
//~| ERROR malformed `proc_macro_derive` attribute input
pub fn c() {}
#[unsafe(proc_macro_attribute)]

50
tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr
View file

@ -1,11 +1,11 @@
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:26:16
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:26:16
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
@ -40,7 +40,7 @@ LL | #[proc_macro_derive(r#unsafe(Foo))]
| ++
error: `proc_macro_attribute` is not an unsafe attribute
--> $DIR/proc-unsafe-attributes.rs:17:3
--> $DIR/proc-unsafe-attributes.rs:18:3
|
LL | #[unsafe(proc_macro_attribute)]
| ^^^^^^ this is not an unsafe attribute
@ -48,7 +48,7 @@ LL | #[unsafe(proc_macro_attribute)]
= note: extraneous unsafe is not allowed in attributes
error: `allow` is not an unsafe attribute
--> $DIR/proc-unsafe-attributes.rs:22:3
--> $DIR/proc-unsafe-attributes.rs:23:3
|
LL | #[unsafe(allow(dead_code))]
| ^^^^^^ this is not an unsafe attribute
@ -56,7 +56,7 @@ LL | #[unsafe(allow(dead_code))]
= note: extraneous unsafe is not allowed in attributes
error: `allow` is not an unsafe attribute
--> $DIR/proc-unsafe-attributes.rs:26:3
--> $DIR/proc-unsafe-attributes.rs:27:3
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^ this is not an unsafe attribute
@ -64,7 +64,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))]
= note: extraneous unsafe is not allowed in attributes
error: expected identifier, found keyword `unsafe`
--> $DIR/proc-unsafe-attributes.rs:26:16
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^ expected identifier, found keyword
@ -93,13 +93,13 @@ LL | #[proc_macro_derive(unsafe(Foo))]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the `#[proc_macro_attribute]` attribute is only usable with crates of the `proc-macro` crate type
--> $DIR/proc-unsafe-attributes.rs:17:1
--> $DIR/proc-unsafe-attributes.rs:18:1
|
LL | #[unsafe(proc_macro_attribute)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:26:16
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
@ -107,7 +107,24 @@ LL | #[unsafe(allow(unsafe(dead_code)))]
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:26:16
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/proc-unsafe-attributes.rs:12:1
|
LL | #[proc_macro_derive(unsafe(Foo))]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^-----^^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
@ -115,21 +132,14 @@ LL | #[unsafe(allow(unsafe(dead_code)))]
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:26:16
--> $DIR/proc-unsafe-attributes.rs:27:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0452]: malformed lint attribute input
--> $DIR/proc-unsafe-attributes.rs:26:16
|
LL | #[unsafe(allow(unsafe(dead_code)))]
| ^^^^^^^^^^^^^^^^^ bad attribute argument
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: aborting due to 18 previous errors
error: aborting due to 17 previous errors
For more information about this error, try `rustc --explain E0452`.
Some errors have detailed explanations: E0452, E0565.
For more information about an error, try `rustc --explain E0452`.

2
tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.rs
View file

@ -57,7 +57,7 @@
// see gated-link-args.rs
// see issue-43106-gating-of-macro_escape.rs for crate-level; but non crate-level is below at "2700"
// (cannot easily test gating of crate-level #[no_std]; but non crate-level is below at "2600")
#![proc_macro_derive()] //~ WARN `#[proc_macro_derive]` only has an effect
#![proc_macro_derive(Test)] //~ WARN `#[proc_macro_derive]` only has an effect
#![doc = "2400"]
#![cold] //~ WARN attribute should be applied to a function
//~^ WARN this was previously accepted

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

@ -367,12 +367,6 @@ warning: `#[should_panic]` only has an effect on functions
LL | #![should_panic]
| ^^^^^^^^^^^^^^^^
warning: `#[proc_macro_derive]` only has an effect on functions
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:60:1
|
LL | #![proc_macro_derive()]
| ^^^^^^^^^^^^^^^^^^^^^^^
warning: attribute should be applied to an `extern` block with non-Rust ABI
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:64:1
|
@ -409,6 +403,12 @@ warning: `#[must_use]` has no effect when applied to a module
LL | #![must_use]
| ^^^^^^^^^^^^
warning: `#[proc_macro_derive]` only has an effect on functions
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:60:1
|
LL | #![proc_macro_derive(Test)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: attribute should be applied to a function definition
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:62:1
|

14
tests/ui/feature-gates/issue-43106-gating-of-proc_macro_derive.rs
View file

@ -7,27 +7,27 @@
// signal errors, making it incompatible with the "warnings only"
// nature of issue-43106-gating-of-builtin-attrs.rs
#[proc_macro_derive()]
#[proc_macro_derive(Test)]
//~^ ERROR the `#[proc_macro_derive]` attribute may only be used on bare functions
mod proc_macro_derive1 {
mod inner { #![proc_macro_derive()] }
mod inner { #![proc_macro_derive(Test)] }
// (no error issued here if there was one on outer module)
}
mod proc_macro_derive2 {
mod inner { #![proc_macro_derive()] }
mod inner { #![proc_macro_derive(Test)] }
//~^ ERROR the `#[proc_macro_derive]` attribute may only be used on bare functions
#[proc_macro_derive()] fn f() { }
#[proc_macro_derive(Test)] fn f() { }
//~^ ERROR the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro`
#[proc_macro_derive()] struct S;
#[proc_macro_derive(Test)] struct S;
//~^ ERROR the `#[proc_macro_derive]` attribute may only be used on bare functions
#[proc_macro_derive()] type T = S;
#[proc_macro_derive(Test)] type T = S;
//~^ ERROR the `#[proc_macro_derive]` attribute may only be used on bare functions
#[proc_macro_derive()] impl S { }
#[proc_macro_derive(Test)] impl S { }
//~^ ERROR the `#[proc_macro_derive]` attribute may only be used on bare functions
}

24
tests/ui/feature-gates/issue-43106-gating-of-proc_macro_derive.stderr
View file

@ -1,38 +1,38 @@
error: the `#[proc_macro_derive]` attribute may only be used on bare functions
--> $DIR/issue-43106-gating-of-proc_macro_derive.rs:10:1
|
LL | #[proc_macro_derive()]
| ^^^^^^^^^^^^^^^^^^^^^^
LL | #[proc_macro_derive(Test)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the `#[proc_macro_derive]` attribute may only be used on bare functions
--> $DIR/issue-43106-gating-of-proc_macro_derive.rs:18:17
|
LL | mod inner { #![proc_macro_derive()] }
| ^^^^^^^^^^^^^^^^^^^^^^^
LL | mod inner { #![proc_macro_derive(Test)] }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro` crate type
--> $DIR/issue-43106-gating-of-proc_macro_derive.rs:21:5
|
LL | #[proc_macro_derive()] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^
LL | #[proc_macro_derive(Test)] fn f() { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the `#[proc_macro_derive]` attribute may only be used on bare functions
--> $DIR/issue-43106-gating-of-proc_macro_derive.rs:24:5
|
LL | #[proc_macro_derive()] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^
LL | #[proc_macro_derive(Test)] struct S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the `#[proc_macro_derive]` attribute may only be used on bare functions
--> $DIR/issue-43106-gating-of-proc_macro_derive.rs:27:5
|
LL | #[proc_macro_derive()] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^
LL | #[proc_macro_derive(Test)] type T = S;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: the `#[proc_macro_derive]` attribute may only be used on bare functions
--> $DIR/issue-43106-gating-of-proc_macro_derive.rs:30:5
|
LL | #[proc_macro_derive()] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^
LL | #[proc_macro_derive(Test)] impl S { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 6 previous errors

51
tests/ui/proc-macro/attribute.rs
View file

@ -6,68 +6,85 @@
extern crate proc_macro;
use proc_macro::*;
#[proc_macro_derive] //~ ERROR malformed `proc_macro_derive` attribute
#[proc_macro_derive]
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected this to be a list
pub fn foo1(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive = ""] //~ ERROR malformed `proc_macro_derive` attribute
#[proc_macro_derive = ""]
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected this to be a list
pub fn foo2(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d3, a, b)]
//~^ ERROR attribute must have either one or two arguments
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE the only valid argument here is `attributes`
pub fn foo3(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d4, attributes(a), b)]
//~^ ERROR attribute must have either one or two arguments
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE didn't expect any arguments here
pub fn foo4(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive("a")]
//~^ ERROR: not a meta item
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE didn't expect a literal here
pub fn foo5(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d6 = "")]
//~^ ERROR: must only be one word
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE didn't expect any arguments here
pub fn foo6(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(m::d7)]
//~^ ERROR: must only be one word
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected a valid identifier here
pub fn foo7(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d8(a))]
//~^ ERROR: must only be one word
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE didn't expect any arguments here
pub fn foo8(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(self)]
//~^ ERROR: `self` cannot be a name of derive macro
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected a valid identifier here
pub fn foo9(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(PartialEq)] // OK
pub fn foo10(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d11, a)]
//~^ ERROR: second argument must be `attributes`
//~| ERROR: attribute must be of form: `attributes(foo, bar)`
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE the only valid argument here is `attributes`
pub fn foo11(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d12, attributes)]
//~^ ERROR: attribute must be of form: `attributes(foo, bar)`
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected this to be a list
pub fn foo12(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d13, attributes("a"))]
//~^ ERROR: attribute must be a meta item, not a literal
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected a valid identifier here
pub fn foo13(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d14, attributes(a = ""))]
//~^ ERROR: attribute must only be a single word
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE didn't expect any arguments here
pub fn foo14(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d15, attributes(m::a))]
//~^ ERROR: attribute must only be a single word
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected a valid identifier here
pub fn foo15(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d16, attributes(a(b)))]
//~^ ERROR: attribute must only be a single word
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE didn't expect any arguments here
pub fn foo16(input: TokenStream) -> TokenStream { input }
#[proc_macro_derive(d17, attributes(self))]
//~^ ERROR: `self` cannot be a name of derive helper attribute
//~^ ERROR malformed `proc_macro_derive` attribute
//~| NOTE expected a valid identifier here
pub fn foo17(input: TokenStream) -> TokenStream { input }

158
tests/ui/proc-macro/attribute.stderr
View file

@ -1,104 +1,148 @@
error: malformed `proc_macro_derive` attribute input
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:9:1
|
LL | #[proc_macro_derive]
| ^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
| ^^^^^^^^^^^^^^^^^^^^
| |
| expected this to be a list
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:12:1
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:14:1
|
LL | #[proc_macro_derive = ""]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| expected this to be a list
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: attribute must have either one or two arguments
--> $DIR/attribute.rs:15:1
|
LL | #[proc_macro_derive(d3, a, b)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: attribute must have either one or two arguments
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:19:1
|
LL | #[proc_macro_derive(d4, attributes(a), b)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | #[proc_macro_derive(d3, a, b)]
| ^^^^^^^^^^^^^^^^^^^^^^^^-^^^^^
| | |
| | the only valid argument here is `attributes`
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: not a meta item
--> $DIR/attribute.rs:23:21
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:24:1
|
LL | #[proc_macro_derive(d4, attributes(a), b)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-^^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:29:1
|
LL | #[proc_macro_derive("a")]
| ^^^
| ^^^^^^^^^^^^^^^^^^^^---^^
| | |
| | didn't expect a literal here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: must only be one word
--> $DIR/attribute.rs:27:21
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:34:1
|
LL | #[proc_macro_derive(d6 = "")]
| ^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^----^^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: must only be one word
--> $DIR/attribute.rs:31:21
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:39:1
|
LL | #[proc_macro_derive(m::d7)]
| ^^^^^
| ^^^^^^^^^^^^^^^^^^^^-----^^
| | |
| | expected a valid identifier here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: must only be one word
--> $DIR/attribute.rs:35:21
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:44:1
|
LL | #[proc_macro_derive(d8(a))]
| ^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^---^^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: `self` cannot be a name of derive macro
--> $DIR/attribute.rs:39:21
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:49:1
|
LL | #[proc_macro_derive(self)]
| ^^^^
| ^^^^^^^^^^^^^^^^^^^^----^^
| | |
| | expected a valid identifier here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: second argument must be `attributes`
--> $DIR/attribute.rs:46:26
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:57:1
|
LL | #[proc_macro_derive(d11, a)]
| ^
| ^^^^^^^^^^^^^^^^^^^^^^^^^-^^
| | |
| | the only valid argument here is `attributes`
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: attribute must be of form: `attributes(foo, bar)`
--> $DIR/attribute.rs:46:26
|
LL | #[proc_macro_derive(d11, a)]
| ^
error: attribute must be of form: `attributes(foo, bar)`
--> $DIR/attribute.rs:51:26
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:62:1
|
LL | #[proc_macro_derive(d12, attributes)]
| ^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^----------^^
| | |
| | expected this to be a list
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: attribute must be a meta item, not a literal
--> $DIR/attribute.rs:55:37
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:67:1
|
LL | #[proc_macro_derive(d13, attributes("a"))]
| ^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---^^^
| | |
| | expected a valid identifier here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: attribute must only be a single word
--> $DIR/attribute.rs:59:37
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:72:1
|
LL | #[proc_macro_derive(d14, attributes(a = ""))]
| ^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----^^^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: attribute must only be a single word
--> $DIR/attribute.rs:63:37
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:77:1
|
LL | #[proc_macro_derive(d15, attributes(m::a))]
| ^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----^^^
| | |
| | expected a valid identifier here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: attribute must only be a single word
--> $DIR/attribute.rs:67:37
error[E0565]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:82:1
|
LL | #[proc_macro_derive(d16, attributes(a(b)))]
| ^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---^^^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: `self` cannot be a name of derive helper attribute
--> $DIR/attribute.rs:71:37
error[E0539]: malformed `proc_macro_derive` attribute input
--> $DIR/attribute.rs:87:1
|
LL | #[proc_macro_derive(d17, attributes(self))]
| ^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----^^^
| | |
| | expected a valid identifier here
| help: must be of the form: `#[proc_macro_derive(TraitName, /*opt*/ attributes(name1, name2, ...))]`
error: aborting due to 17 previous errors
error: aborting due to 16 previous errors
Some errors have detailed explanations: E0539, E0565.
For more information about an error, try `rustc --explain E0539`.

24
tests/ui/proc-macro/invalid-attributes.rs
View file

@ -7,20 +7,32 @@ extern crate proc_macro;
use proc_macro::TokenStream;
#[proc_macro = "test"] //~ ERROR malformed `proc_macro` attribute
#[proc_macro = "test"]
//~^ ERROR malformed `proc_macro` attribute
//~| NOTE didn't expect any arguments here
pub fn a(a: TokenStream) -> TokenStream { a }
#[proc_macro()] //~ ERROR malformed `proc_macro` attribute
#[proc_macro()]
//~^ ERROR malformed `proc_macro` attribute
//~| NOTE didn't expect any arguments here
pub fn c(a: TokenStream) -> TokenStream { a }
#[proc_macro(x)] //~ ERROR malformed `proc_macro` attribute
#[proc_macro(x)]
//~^ ERROR malformed `proc_macro` attribute
//~| NOTE didn't expect any arguments here
pub fn d(a: TokenStream) -> TokenStream { a }
#[proc_macro_attribute = "test"] //~ ERROR malformed `proc_macro_attribute` attribute
#[proc_macro_attribute = "test"]
//~^ ERROR malformed `proc_macro_attribute` attribute
//~| NOTE didn't expect any arguments here
pub fn e(_: TokenStream, a: TokenStream) -> TokenStream { a }
#[proc_macro_attribute()] //~ ERROR malformed `proc_macro_attribute` attribute
#[proc_macro_attribute()]
//~^ ERROR malformed `proc_macro_attribute` attribute
//~| NOTE didn't expect any arguments here
pub fn g(_: TokenStream, a: TokenStream) -> TokenStream { a }
#[proc_macro_attribute(x)] //~ ERROR malformed `proc_macro_attribute` attribute
#[proc_macro_attribute(x)]
//~^ ERROR malformed `proc_macro_attribute` attribute
//~| NOTE didn't expect any arguments here
pub fn h(_: TokenStream, a: TokenStream) -> TokenStream { a }

63
tests/ui/proc-macro/invalid-attributes.stderr
View file

@ -1,38 +1,57 @@
error: malformed `proc_macro` attribute input
error[E0565]: malformed `proc_macro` attribute input
--> $DIR/invalid-attributes.rs:10:1
|
LL | #[proc_macro = "test"]
| ^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro]`
| ^^^^^^^^^^^^^--------^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro]`
error: malformed `proc_macro` attribute input
--> $DIR/invalid-attributes.rs:13:1
error[E0565]: malformed `proc_macro` attribute input
--> $DIR/invalid-attributes.rs:15:1
|
LL | #[proc_macro()]
| ^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro]`
| ^^^^^^^^^^^^--^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro]`
error: malformed `proc_macro` attribute input
--> $DIR/invalid-attributes.rs:16:1
error[E0565]: malformed `proc_macro` attribute input
--> $DIR/invalid-attributes.rs:20:1
|
LL | #[proc_macro(x)]
| ^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro]`
| ^^^^^^^^^^^^---^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro]`
error: malformed `proc_macro_attribute` attribute input
--> $DIR/invalid-attributes.rs:19:1
|
LL | #[proc_macro_attribute = "test"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_attribute]`
error: malformed `proc_macro_attribute` attribute input
--> $DIR/invalid-attributes.rs:22:1
|
LL | #[proc_macro_attribute()]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_attribute]`
error: malformed `proc_macro_attribute` attribute input
error[E0565]: malformed `proc_macro_attribute` attribute input
--> $DIR/invalid-attributes.rs:25:1
|
LL | #[proc_macro_attribute = "test"]
| ^^^^^^^^^^^^^^^^^^^^^^^--------^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_attribute]`
error[E0565]: malformed `proc_macro_attribute` attribute input
--> $DIR/invalid-attributes.rs:30:1
|
LL | #[proc_macro_attribute()]
| ^^^^^^^^^^^^^^^^^^^^^^--^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_attribute]`
error[E0565]: malformed `proc_macro_attribute` attribute input
--> $DIR/invalid-attributes.rs:35:1
|
LL | #[proc_macro_attribute(x)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[proc_macro_attribute]`
| ^^^^^^^^^^^^^^^^^^^^^^---^
| | |
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro_attribute]`
error: aborting due to 6 previous errors
For more information about this error, try `rustc --explain E0565`.