Commit d5525a73009e2c61b09daa69df79064530bd4dcf | rust

RELEASES.md+85

...	@@ -1,3 +1,88 @@	...	@@ -1,3 +1,88 @@
		1	Version 1.92.0 (2025-12-11)
		2	==========================
		3
		4	<a id="1.92.0-Language"></a>
		5
		6	Language
		7	--------
		8	- [Document `MaybeUninit` representation and validity](https://github.com/rust-lang/rust/pull/140463)
		9	- [Allow `&raw [mut \| const]` for union field in safe code](https://github.com/rust-lang/rust/pull/141469)
		10	- [Prefer item bounds of associated types over where-bounds for auto-traits and `Sized`](https://github.com/rust-lang/rust/pull/144064)
		11	- [Do not materialize `X` in `[X; 0]` when `X` is unsizing a const](https://github.com/rust-lang/rust/pull/145277)
		12	- [Support combining `#[track_caller]` and `#[no_mangle]` (requires every declaration specifying `#[track_caller]` as well)](https://github.com/rust-lang/rust/pull/145724)
		13	- [Make never type lints `never_type_fallback_flowing_into_unsafe` and `dependency_on_unit_never_type_fallback` deny-by-default](https://github.com/rust-lang/rust/pull/146167)
		14	- [Allow specifying multiple bounds for same associated item, except in trait objects](https://github.com/rust-lang/rust/pull/146593)
		15	- [Slightly strengthen higher-ranked region handling in coherence](https://github.com/rust-lang/rust/pull/146725)
		16	- [The `unused_must_use` lint no longer warns on `Result<(), Uninhabited>` (for instance, `Result<(), !>`), or `ControlFlow<Uninhabited, ()>`](https://github.com/rust-lang/rust/pull/147382). This avoids having to check for an error that can never happen.
		17
		18	<a id="1.92.0-Compiler"></a>
		19
		20	Compiler
		21	--------
		22	- [Make `mips64el-unknown-linux-muslabi64` link dynamically](https://github.com/rust-lang/rust/pull/146858)
		23	- [Remove current code for embedding command-line args in PDB](https://github.com/rust-lang/rust/pull/147022)
		24	Command-line information is typically not needed by debugging tools, and the removed code
		25	was causing problems for incremental builds even on targets that don't use PDB debuginfo.
		26
		27	<a id="1.92.0-Libraries"></a>
		28
		29	Libraries
		30	---------
		31	- [Specialize `Iterator::eq{_by}` for `TrustedLen` iterators](https://github.com/rust-lang/rust/pull/137122)
		32	- [Simplify `Extend` for tuples](https://github.com/rust-lang/rust/pull/138799)
		33	- [Added details to `Debug` for `EncodeWide`](https://github.com/rust-lang/rust/pull/140153).
		34	- [`iter::Repeat::last`](https://github.com/rust-lang/rust/pull/147258) and [`count`](https://github.com/rust-lang/rust/pull/146410) will now panic, rather than looping infinitely.
		35
		36	<a id="1.92.0-Stabilized-APIs"></a>
		37
		38	Stabilized APIs
		39	---------------
		40
		41	- [`NonZero<u{N}>::div_ceil`](https://doc.rust-lang.org/stable/std/num/struct.NonZero.html#method.div_ceil)
		42	- [`Location::file_as_c_str`](https://doc.rust-lang.org/stable/std/panic/struct.Location.html#method.file_as_c_str)
		43	- [`RwLockWriteGuard::downgrade`](https://doc.rust-lang.org/stable/std/sync/struct.RwLockWriteGuard.html#method.downgrade)
		44	- [`Box::new_zeroed`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_zeroed)
		45	- [`Box::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_zeroed_slice)
		46	- [`Rc::new_zeroed`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_zeroed)
		47	- [`Rc::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_zeroed_slice)
		48	- [`Arc::new_zeroed`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_zeroed)
		49	- [`Arc::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_zeroed_slice)
		50	- [`btree_map::Entry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/btree_map/enum.Entry.html#method.insert_entry)
		51	- [`btree_map::VacantEntry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/btree_map/struct.VacantEntry.html#method.insert_entry)
		52	- [`impl Extend<proc_macro::Group> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CGroup%3E-for-TokenStream)
		53	- [`impl Extend<proc_macro::Literal> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CLiteral%3E-for-TokenStream)
		54	- [`impl Extend<proc_macro::Punct> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CPunct%3E-for-TokenStream)
		55	- [`impl Extend<proc_macro::Ident> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CIdent%3E-for-TokenStream)
		56
		57	These previously stable APIs are now stable in const contexts:
		58
		59	- [`<[_]>::rotate_left`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.rotate_left)
		60	- [`<[_]>::rotate_right`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.rotate_right)
		61
		62	<a id="1.92.0-Cargo"></a>
		63
		64	Cargo
		65	-----
		66	- [Added a new chapter](https://github.com/rust-lang/cargo/issues/16119) to the Cargo book, ["Optimizing Build Performance"](https://doc.rust-lang.org/stable/cargo/guide/build-performance.html).
		67
		68	<a id="1.92.0-Rustdoc"></a>
		69
		70	Rustdoc
		71	-----
		72	- [If a trait item appears in rustdoc search, hide the corresponding impl items](https://github.com/rust-lang/rust/pull/145898). Previously a search for "last" would show both `Iterator::last` as well as impl methods like `std::vec::IntoIter::last`. Now these impl methods will be hidden, freeing up space for inherent methods like `BTreeSet::last`.
		73	- [Relax rules for identifiers in search](https://github.com/rust-lang/rust/pull/147860). Previously you could only search for identifiers that were valid in rust code, now searches only need to be valid as part of an identifier. For example, you can now perform a search that starts with a digit.
		74
		75	<a id="1.92.0-Compatibility-Notes"></a>
		76
		77	Compatibility Notes
		78	-------------------
		79	* [Fix backtraces with `-C panic=abort` on Linux by generating unwind tables by default](https://github.com/rust-lang/rust/pull/143613). Build with `-C force-unwind-tables=no` to keep omitting unwind tables.
		80	- As part of the larger effort refactoring compiler built-in attributes and their diagnostics, [the future-compatibility lint `invalid_macro_export_arguments` is upgraded to deny-by-default and will be reported in dependencies too.](https://github.com/rust-lang/rust/pull/143857)
		81	- [Update the minimum external LLVM to 20](https://github.com/rust-lang/rust/pull/145071)
		82	- [Prevent downstream `impl DerefMut for Pin<LocalType>`](https://github.com/rust-lang/rust/pull/145608)
		83	- [Don't apply temporary lifetime extension rules to the arguments of non-extended `pin!` and formatting macros](https://github.com/rust-lang/rust/pull/145838)
		84
		85
1	Version 1.91.1 (2025-11-10)	86	Version 1.91.1 (2025-11-10)
2	===========================	87	===========================
3		88

compiler/rustc_ast_lowering/src/delegation.rs+28

...	@@ -44,6 +44,7 @@ use hir::{BodyId, HirId};	...	@@ -44,6 +44,7 @@ use hir::{BodyId, HirId};
44	use rustc_abi::ExternAbi;	44	use rustc_abi::ExternAbi;
45	use rustc_ast::*;	45	use rustc_ast::*;
46	use rustc_errors::ErrorGuaranteed;	46	use rustc_errors::ErrorGuaranteed;
		47	use rustc_hir::attrs::{AttributeKind, InlineAttr};
47	use rustc_hir::def_id::DefId;	48	use rustc_hir::def_id::DefId;
48	use rustc_middle::span_bug;	49	use rustc_middle::span_bug;
49	use rustc_middle::ty::{Asyncness, ResolverAstLowering};	50	use rustc_middle::ty::{Asyncness, ResolverAstLowering};
...	@@ -87,6 +88,8 @@ impl<'hir> LoweringContext<'_, 'hir> {	...	@@ -87,6 +88,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
87	let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span, is_in_trait_impl);	88	let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span, is_in_trait_impl);
88	match sig_id {	89	match sig_id {
89	Ok(sig_id) => {	90	Ok(sig_id) => {
		91	self.add_inline_attribute_if_needed(span);
		92
90	let is_method = self.is_method(sig_id, span);	93	let is_method = self.is_method(sig_id, span);
91	let (param_count, c_variadic) = self.param_count(sig_id);	94	let (param_count, c_variadic) = self.param_count(sig_id);
92	let decl = self.lower_delegation_decl(sig_id, param_count, c_variadic, span);	95	let decl = self.lower_delegation_decl(sig_id, param_count, c_variadic, span);
...	@@ -100,6 +103,31 @@ impl<'hir> LoweringContext<'_, 'hir> {	...	@@ -100,6 +103,31 @@ impl<'hir> LoweringContext<'_, 'hir> {
100	}	103	}
101	}	104	}
102		105
		106	fn add_inline_attribute_if_needed(&mut self, span: Span) {
		107	const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
		108	let create_inline_attr_slice =
		109	\|\| [hir::Attribute::Parsed(AttributeKind::Inline(InlineAttr::Hint, span))];
		110
		111	let new_attributes = match self.attrs.get(&PARENT_ID) {
		112	Some(attrs) => {
		113	// Check if reuse already specifies any inline attribute, if so, do nothing
		114	if attrs
		115	.iter()
		116	.any(\|a\| matches!(a, hir::Attribute::Parsed(AttributeKind::Inline(..))))
		117	{
		118	return;
		119	}
		120
		121	self.arena.alloc_from_iter(
		122	attrs.into_iter().map(\|a\| a.clone()).chain(create_inline_attr_slice()),
		123	)
		124	}
		125	None => self.arena.alloc_from_iter(create_inline_attr_slice()),
		126	};
		127
		128	self.attrs.insert(PARENT_ID, new_attributes);
		129	}
		130
103	fn get_delegation_sig_id(	131	fn get_delegation_sig_id(
104	&self,	132	&self,
105	item_id: NodeId,	133	item_id: NodeId,

compiler/rustc_attr_parsing/src/attributes/cfg.rs+29-53

 @@ -2,16 +2,16 @@ use std::convert::identity;
 use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
-use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, NodeId, ast, token};
+use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, ast, token};
 use rustc_errors::{Applicability, PResult};
 use rustc_feature::{AttrSuggestionStyle, AttributeTemplate, Features, template};
 use rustc_hir::attrs::CfgEntry;
+use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrPath, RustcVersion};
 use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_parse::{exp, parse_in};
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
-use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::UNEXPECTED_CFGS;
 use rustc_session::parse::{ParseSess, feature_err};
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 @@ -23,10 +23,7 @@ use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, CfgAttrBadDelim, MetaBadDelimSugg,
     ParsedDescription,
 };
-use crate::{
+use crate::{AttributeParser, fluent_generated, parse_version, session_diagnostics, try_gate_cfg};
-    AttributeParser, CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics,
-    try_gate_cfg,
-};
 pub const CFG_TEMPLATE: AttributeTemplate = template!(
     List: &["predicate"],
 @@ -195,43 +192,46 @@ fn parse_name_value<S: Stage>(
         }
     };
-    Ok(CfgEntry::NameValue { name, name_span, value, span })
+    match cx.sess.psess.check_config.expecteds.get(&name) {
+        Some(ExpectedValues::Some(values)) if !values.contains(&value.map(|(v, _)| v)) => cx
+            .emit_lint(
+                UNEXPECTED_CFGS,
+                AttributeLintKind::UnexpectedCfgValue((name, name_span), value),
+                span,
+            ),
+        None if cx.sess.psess.check_config.exhaustive_names => cx.emit_lint(
+            UNEXPECTED_CFGS,
+            AttributeLintKind::UnexpectedCfgName((name, name_span), value),
+            span,
+        ),
+        _ => { /* not unexpected */ }
+    }
+    Ok(CfgEntry::NameValue { name, value: value.map(|(v, _)| v), span })
 }
-pub fn eval_config_entry(
+pub fn eval_config_entry(sess: &Session, cfg_entry: &CfgEntry) -> EvalConfigResult {
-    sess: &Session,
-    cfg_entry: &CfgEntry,
-    id: NodeId,
-    emit_lints: ShouldEmit,
-) -> EvalConfigResult {
     match cfg_entry {
         CfgEntry::All(subs, ..) => {
-            let mut all = None;
             for sub in subs {
-                let res = eval_config_entry(sess, sub, id, emit_lints);
+                let res = eval_config_entry(sess, sub);
-                // We cannot short-circuit because `eval_config_entry` emits some lints
                 if !res.as_bool() {
-                    all.get_or_insert(res);
+                    return res;
                 }
             }
-            all.unwrap_or_else(|| EvalConfigResult::True)
+            EvalConfigResult::True
         }
         CfgEntry::Any(subs, span) => {
-            let mut any = None;
             for sub in subs {
-                let res = eval_config_entry(sess, sub, id, emit_lints);
+                let res = eval_config_entry(sess, sub);
-                // We cannot short-circuit because `eval_config_entry` emits some lints
                 if res.as_bool() {
-                    any.get_or_insert(res);
+                    return res;
                 }
             }
-            any.unwrap_or_else(|| EvalConfigResult::False {
+            EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
-                reason: cfg_entry.clone(),
-                reason_span: *span,
-            })
         }
         CfgEntry::Not(sub, span) => {
-            if eval_config_entry(sess, sub, id, emit_lints).as_bool() {
+            if eval_config_entry(sess, sub).as_bool() {
                 EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             } else {
                 EvalConfigResult::True
 @@ -244,32 +244,8 @@ pub fn eval_config_entry(
                 EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             }
         }
-        CfgEntry::NameValue { name, name_span, value, span } => {
+        CfgEntry::NameValue { name, value, span } => {
-            if let ShouldEmit::ErrorsAndLints = emit_lints {
+            if sess.psess.config.contains(&(*name, *value)) {
-                match sess.psess.check_config.expecteds.get(name) {
-                    Some(ExpectedValues::Some(values))
-                        if !values.contains(&value.map(|(v, _)| v)) =>
-                    {
-                        id.emit_span_lint(
-                            sess,
-                            UNEXPECTED_CFGS,
-                            *span,
-                            BuiltinLintDiag::UnexpectedCfgValue((*name, *name_span), *value),
-                        );
-                    }
-                    None if sess.psess.check_config.exhaustive_names => {
-                        id.emit_span_lint(
-                            sess,
-                            UNEXPECTED_CFGS,
-                            *span,
-                            BuiltinLintDiag::UnexpectedCfgName((*name, *name_span), *value),
-                        );
-                    }
-                    _ => { /* not unexpected */ }
-                }
-            }
-            if sess.psess.config.contains(&(*name, value.map(|(v, _)| v))) {
                 EvalConfigResult::True
             } else {
                 EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }

compiler/rustc_attr_parsing/src/attributes/cfg_old.rs+5-4

 @@ -2,6 +2,7 @@ use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, Nod
 use rustc_ast_pretty::pprust;
 use rustc_feature::{Features, GatedCfg, find_gated_cfg};
 use rustc_hir::RustcVersion;
+use rustc_hir::lints::AttributeLintKind;
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
 use rustc_session::lint::builtin::UNEXPECTED_CFGS;
 @@ -51,10 +52,10 @@ pub fn cfg_matches(
                     sess,
                     UNEXPECTED_CFGS,
                     cfg.span,
-                    BuiltinLintDiag::UnexpectedCfgValue(
+                    BuiltinLintDiag::AttributeLint(AttributeLintKind::UnexpectedCfgValue(
                         (cfg.name, cfg.name_span),
                         cfg.value.map(|v| (v, cfg.value_span.unwrap())),
-                    ),
+                    )),
                 );
             }
             None if sess.psess.check_config.exhaustive_names => {
 @@ -62,10 +63,10 @@ pub fn cfg_matches(
                     sess,
                     UNEXPECTED_CFGS,
                     cfg.span,
-                    BuiltinLintDiag::UnexpectedCfgName(
+                    BuiltinLintDiag::AttributeLint(AttributeLintKind::UnexpectedCfgName(
                         (cfg.name, cfg.name_span),
                         cfg.value.map(|v| (v, cfg.value_span.unwrap())),
-                    ),
+                    )),
                 );
             }
             _ => { /* not unexpected */ }

compiler/rustc_builtin_macros/src/cfg.rs+1-7

 @@ -26,13 +26,7 @@ pub(crate) fn expand_cfg(
     ExpandResult::Ready(match parse_cfg(cx, sp, tts) {
         Ok(cfg) => {
-            let matches_cfg = attr::eval_config_entry(
+            let matches_cfg = attr::eval_config_entry(cx.sess, &cfg).as_bool();
-                cx.sess,
-                &cfg,
-                cx.current_expansion.lint_node_id,
-                ShouldEmit::ErrorsAndLints,
-            )
-            .as_bool();
             MacEager::expr(cx.expr_bool(sp, matches_cfg))
         }

compiler/rustc_builtin_macros/src/cfg_select.rs+4-12

 @@ -1,7 +1,7 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
-    CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, ShouldEmit, parse_cfg_select,
+    CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, parse_cfg_select,
 };
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
 use rustc_span::{Ident, Span, sym};
 @@ -10,21 +10,13 @@ use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
 /// Selects the first arm whose predicate evaluates to true.
 fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
-    let mut result = None;
     for (cfg, tt, arm_span) in branches.reachable {
-        if let EvalConfigResult::True = attr::eval_config_entry(
+        if let EvalConfigResult::True = attr::eval_config_entry(&ecx.sess, &cfg) {
-            &ecx.sess,
+            return Some((tt, arm_span));
-            &cfg,
-            ecx.current_expansion.lint_node_id,
-            ShouldEmit::ErrorsAndLints,
-        ) {
-            // FIXME(#149215) Ideally we should short-circuit here, but `eval_config_entry` currently emits lints so we cannot do this yet.
-            result.get_or_insert((tt, arm_span));
         }
     }
-    let wildcard = branches.wildcard.map(|(_, tt, span)| (tt, span));
+    branches.wildcard.map(|(_, tt, span)| (tt, span))
-    result.or(wildcard)
 }
 pub(super) fn expand_cfg_select<'cx>(

compiler/rustc_codegen_ssa/src/back/link.rs+2-5

...	@@ -13,8 +13,7 @@ use find_msvc_tools;	...	@@ -13,8 +13,7 @@ use find_msvc_tools;
13	use itertools::Itertools;	13	use itertools::Itertools;
14	use regex::Regex;	14	use regex::Regex;
15	use rustc_arena::TypedArena;	15	use rustc_arena::TypedArena;
16	use rustc_ast::CRATE_NODE_ID;	16	use rustc_attr_parsing::eval_config_entry;
17	use rustc_attr_parsing::{ShouldEmit, eval_config_entry};
18	use rustc_data_structures::fx::FxIndexSet;	17	use rustc_data_structures::fx::FxIndexSet;
19	use rustc_data_structures::memmap::Mmap;	18	use rustc_data_structures::memmap::Mmap;
20	use rustc_data_structures::temp_dir::MaybeTempDir;	19	use rustc_data_structures::temp_dir::MaybeTempDir;
...	@@ -3029,9 +3028,7 @@ fn add_dynamic_crate(cmd: &mut dyn Linker, sess: &Session, cratepath: &Path) {	...	@@ -3029,9 +3028,7 @@ fn add_dynamic_crate(cmd: &mut dyn Linker, sess: &Session, cratepath: &Path) {
3029		3028
3030	fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {	3029	fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {
3031	match lib.cfg {	3030	match lib.cfg {
3032	Some(ref cfg) => {	3031	Some(ref cfg) => eval_config_entry(sess, cfg).as_bool(),
3033	eval_config_entry(sess, cfg, CRATE_NODE_ID, ShouldEmit::ErrorsAndLints).as_bool()
3034	}
3035	None => true,	3032	None => true,
3036	}	3033	}
3037	}	3034	}

compiler/rustc_expand/src/config.rs+8-24

 @@ -163,10 +163,7 @@ pub fn pre_configure_attrs(sess: &Session, attrs: &[Attribute]) -> ast::AttrVec
         .iter()
         .flat_map(|attr| strip_unconfigured.process_cfg_attr(attr))
         .take_while(|attr| {
-            !is_cfg(attr)
+            !is_cfg(attr) || strip_unconfigured.cfg_true(attr, ShouldEmit::Nothing).as_bool()
-                || strip_unconfigured
-                    .cfg_true(attr, strip_unconfigured.lint_node_id, ShouldEmit::Nothing)
-                    .as_bool()
         })
         .collect()
 }
 @@ -309,14 +306,7 @@ impl<'a> StripUnconfigured<'a> {
             );
         }
-        if !attr::eval_config_entry(
+        if !attr::eval_config_entry(self.sess, &cfg_predicate).as_bool() {
-            self.sess,
-            &cfg_predicate,
-            ast::CRATE_NODE_ID,
-            ShouldEmit::ErrorsAndLints,
-        )
-        .as_bool()
-        {
             return vec![trace_attr];
         }
 @@ -400,23 +390,17 @@ impl<'a> StripUnconfigured<'a> {
     /// Determines if a node with the given attributes should be included in this configuration.
     fn in_cfg(&self, attrs: &[Attribute]) -> bool {
-        attrs.iter().all(|attr| {
+        attrs
-            !is_cfg(attr)
+            .iter()
-                || self.cfg_true(attr, self.lint_node_id, ShouldEmit::ErrorsAndLints).as_bool()
+            .all(|attr| !is_cfg(attr) || self.cfg_true(attr, ShouldEmit::ErrorsAndLints).as_bool())
-        })
     }
-    pub(crate) fn cfg_true(
+    pub(crate) fn cfg_true(&self, attr: &Attribute, emit_errors: ShouldEmit) -> EvalConfigResult {
-        &self,
-        attr: &Attribute,
-        node: NodeId,
-        emit_errors: ShouldEmit,
-    ) -> EvalConfigResult {
         let Some(cfg) = AttributeParser::parse_single(
             self.sess,
             attr,
             attr.span,
-            node,
+            self.lint_node_id,
             self.features,
             emit_errors,
             parse_cfg,
 @@ -426,7 +410,7 @@ impl<'a> StripUnconfigured<'a> {
             return EvalConfigResult::True;
         };
-        eval_config_entry(self.sess, &cfg, self.lint_node_id, emit_errors)
+        eval_config_entry(self.sess, &cfg)
     }
     /// If attributes are not allowed on expressions, emit an error for `attr`

compiler/rustc_expand/src/expand.rs+1-1

...	@@ -2213,7 +2213,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {	...	@@ -2213,7 +2213,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
2213	attr: ast::Attribute,	2213	attr: ast::Attribute,
2214	pos: usize,	2214	pos: usize,
2215	) -> EvalConfigResult {	2215	) -> EvalConfigResult {
2216	let res = self.cfg().cfg_true(&attr, node.node_id(), ShouldEmit::ErrorsAndLints);	2216	let res = self.cfg().cfg_true(&attr, ShouldEmit::ErrorsAndLints);
2217	if res.as_bool() {	2217	if res.as_bool() {
2218	// A trace attribute left in AST in place of the original `cfg` attribute.	2218	// A trace attribute left in AST in place of the original `cfg` attribute.
2219	// It can later be used by lints or other diagnostics.	2219	// It can later be used by lints or other diagnostics.

compiler/rustc_hir/src/attrs/data_structures.rs+1-1

...	@@ -190,7 +190,7 @@ pub enum CfgEntry {	...	@@ -190,7 +190,7 @@ pub enum CfgEntry {
190	Any(ThinVec<CfgEntry>, Span),	190	Any(ThinVec<CfgEntry>, Span),
191	Not(Box<CfgEntry>, Span),	191	Not(Box<CfgEntry>, Span),
192	Bool(bool, Span),	192	Bool(bool, Span),
193	NameValue { name: Symbol, name_span: Span, value: Option<(Symbol, Span)>, span: Span },	193	NameValue { name: Symbol, value: Option<Symbol>, span: Span },
194	Version(Option<RustcVersion>, Span),	194	Version(Option<RustcVersion>, Span),
195	}	195	}
196		196

compiler/rustc_hir_typeck/src/expr.rs+5-1

 @@ -2191,7 +2191,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             };
             self.typeck_results.borrow_mut().fru_field_types_mut().insert(expr.hir_id, fru_tys);
-        } else if adt_kind != AdtKind::Union && !remaining_fields.is_empty() {
+        } else if adt_kind != AdtKind::Union
+            && !remaining_fields.is_empty()
+            //~ non_exhaustive already reported, which will only happen for extern modules
+            && !variant.field_list_has_applicable_non_exhaustive()
+        {
             debug!(?remaining_fields);
             let private_fields: Vec<&ty::FieldDef> = variant
                 .fields

compiler/rustc_lint/messages.ftl+2

...	@@ -416,6 +416,8 @@ lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[re	...	@@ -416,6 +416,8 @@ lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[re
416	lint_improper_ctypes_union_layout_reason = this union has unspecified layout	416	lint_improper_ctypes_union_layout_reason = this union has unspecified layout
417	lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive	417	lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
418		418
		419	lint_improper_ctypes_unsafe_binder = unsafe binders are incompatible with foreign function interfaces
		420
419	lint_int_to_ptr_transmutes = transmuting an integer to a pointer creates a pointer without provenance	421	lint_int_to_ptr_transmutes = transmuting an integer to a pointer creates a pointer without provenance
420	.note = this is dangerous because dereferencing the resulting pointer is undefined behavior	422	.note = this is dangerous because dereferencing the resulting pointer is undefined behavior
421	.note_exposed_provenance = exposed provenance semantics can be used to create a pointer based on some previously exposed provenance	423	.note_exposed_provenance = exposed provenance semantics can be used to create a pointer based on some previously exposed provenance

compiler/rustc_lint/src/early/diagnostics.rs+8-8

 @@ -169,12 +169,6 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
-        BuiltinLintDiag::UnexpectedCfgName(name, value) => {
-            check_cfg::unexpected_cfg_name(sess, tcx, name, value).decorate_lint(diag);
-        }
-        BuiltinLintDiag::UnexpectedCfgValue(name, value) => {
-            check_cfg::unexpected_cfg_value(sess, tcx, name, value).decorate_lint(diag);
-        }
         BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
             let suggestion = match sugg {
                 Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
 @@ -310,8 +304,8 @@ pub fn decorate_builtin_lint(
 }
 pub fn decorate_attribute_lint(
-    _sess: &Session,
+    sess: &Session,
-    _tcx: Option<TyCtxt<'_>>,
+    tcx: Option<TyCtxt<'_>>,
     kind: &AttributeLintKind,
     diag: &mut Diag<'_, ()>,
 ) {
 @@ -367,5 +361,11 @@ pub fn decorate_attribute_lint(
             suggestion: lints::UnsafeAttrOutsideUnsafeSuggestion { left, right },
         }
         .decorate_lint(diag),
+        &AttributeLintKind::UnexpectedCfgName(name, value) => {
+            check_cfg::unexpected_cfg_name(sess, tcx, name, value).decorate_lint(diag)
+        }
+        &AttributeLintKind::UnexpectedCfgValue(name, value) => {
+            check_cfg::unexpected_cfg_value(sess, tcx, name, value).decorate_lint(diag)
+        }
     }
 }

compiler/rustc_lint/src/types/improper_ctypes.rs+3-1

 @@ -669,7 +669,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiSafe
             }
-            ty::UnsafeBinder(_) => todo!("FIXME(unsafe_binder)"),
+            ty::UnsafeBinder(_) => {
+                FfiUnsafe { ty, reason: fluent::lint_improper_ctypes_unsafe_binder, help: None }
+            }
             ty::Param(..)
             | ty::Alias(ty::Projection | ty::Inherent | ty::Free, ..)

compiler/rustc_lint_defs/src/lib.rs+2-2

...	@@ -636,8 +636,6 @@ pub enum BuiltinLintDiag {	...	@@ -636,8 +636,6 @@ pub enum BuiltinLintDiag {
636	},	636	},
637	BreakWithLabelAndLoop(Span),	637	BreakWithLabelAndLoop(Span),
638	UnicodeTextFlow(Span, String),	638	UnicodeTextFlow(Span, String),
639	UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),
640	UnexpectedCfgValue((Symbol, Span), Option<(Symbol, Span)>),
641	DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),	639	DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),
642	SingleUseLifetime {	640	SingleUseLifetime {
643	/// Span of the parameter which declares this lifetime.	641	/// Span of the parameter which declares this lifetime.
...	@@ -733,6 +731,8 @@ pub enum AttributeLintKind {	...	@@ -733,6 +731,8 @@ pub enum AttributeLintKind {
733	attribute_name_span: Span,	731	attribute_name_span: Span,
734	sugg_spans: (Span, Span),	732	sugg_spans: (Span, Span),
735	},	733	},
		734	UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),
		735	UnexpectedCfgValue((Symbol, Span), Option<(Symbol, Span)>),
736	}	736	}
737		737
738	pub type RegisteredTools = FxIndexSet<Ident>;	738	pub type RegisteredTools = FxIndexSet<Ident>;

compiler/rustc_metadata/src/native_libs.rs+2-5

...	@@ -2,8 +2,7 @@ use std::ops::ControlFlow;	...	@@ -2,8 +2,7 @@ use std::ops::ControlFlow;
2	use std::path::{Path, PathBuf};	2	use std::path::{Path, PathBuf};
3		3
4	use rustc_abi::ExternAbi;	4	use rustc_abi::ExternAbi;
5	use rustc_ast::CRATE_NODE_ID;	5	use rustc_attr_parsing::eval_config_entry;
6	use rustc_attr_parsing::{ShouldEmit, eval_config_entry};
7	use rustc_data_structures::fx::FxHashSet;	6	use rustc_data_structures::fx::FxHashSet;
8	use rustc_hir::attrs::{AttributeKind, NativeLibKind, PeImportNameType};	7	use rustc_hir::attrs::{AttributeKind, NativeLibKind, PeImportNameType};
9	use rustc_hir::find_attr;	8	use rustc_hir::find_attr;
...	@@ -188,9 +187,7 @@ pub(crate) fn collect(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> Vec<NativeLib>	...	@@ -188,9 +187,7 @@ pub(crate) fn collect(tcx: TyCtxt<'_>, LocalCrate: LocalCrate) -> Vec<NativeLib>
188		187
189	pub(crate) fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {	188	pub(crate) fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {
190	match lib.cfg {	189	match lib.cfg {
191	Some(ref cfg) => {	190	Some(ref cfg) => eval_config_entry(sess, cfg).as_bool(),
192	eval_config_entry(sess, cfg, CRATE_NODE_ID, ShouldEmit::ErrorsAndLints).as_bool()
193	}
194	None => true,	191	None => true,
195	}	192	}
196	}	193	}

compiler/rustc_resolve/src/diagnostics.rs+1-1

...	@@ -3070,7 +3070,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {	...	@@ -3070,7 +3070,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
3070	continue;	3070	continue;
3071	}	3071	}
3072		3072
3073	let item_was = if let CfgEntry::NameValue { value: Some((feature, _)), .. } = cfg.0 {	3073	let item_was = if let CfgEntry::NameValue { value: Some(feature), .. } = cfg.0 {
3074	errors::ItemWas::BehindFeature { feature, span: cfg.1 }	3074	errors::ItemWas::BehindFeature { feature, span: cfg.1 }
3075	} else {	3075	} else {
3076	errors::ItemWas::CfgOut { span: cfg.1 }	3076	errors::ItemWas::CfgOut { span: cfg.1 }

library/std/src/fs.rs+2-2

...	@@ -1324,7 +1324,7 @@ impl Read for &File {	...	@@ -1324,7 +1324,7 @@ impl Read for &File {
1324	///	1324	///
1325	/// # Platform-specific behavior	1325	/// # Platform-specific behavior
1326	///	1326	///
1327	/// This function currently returns `true` on Unix an `false` on Windows.	1327	/// This function currently returns `true` on Unix and `false` on Windows.
1328	/// Note that this [may change in the future][changes].	1328	/// Note that this [may change in the future][changes].
1329	///	1329	///
1330	/// [changes]: io#platform-specific-behavior	1330	/// [changes]: io#platform-specific-behavior
...	@@ -1385,7 +1385,7 @@ impl Write for &File {	...	@@ -1385,7 +1385,7 @@ impl Write for &File {
1385	///	1385	///
1386	/// # Platform-specific behavior	1386	/// # Platform-specific behavior
1387	///	1387	///
1388	/// This function currently returns `true` on Unix an `false` on Windows.	1388	/// This function currently returns `true` on Unix and `false` on Windows.
1389	/// Note that this [may change in the future][changes].	1389	/// Note that this [may change in the future][changes].
1390	///	1390	///
1391	/// [changes]: io#platform-specific-behavior	1391	/// [changes]: io#platform-specific-behavior

src/bootstrap/src/core/build_steps/test.rs+70-48

 @@ -3,6 +3,9 @@
 //! `./x.py test` (aka [`Kind::Test`]) is currently allowed to reach build steps in other modules.
 //! However, this contains ~all test parts we expect people to be able to build and run locally.
+// (This file should be split up, but having tidy block all changes is not helpful.)
+// ignore-tidy-filelength
 use std::collections::HashSet;
 use std::env::split_paths;
 use std::ffi::{OsStr, OsString};
 @@ -17,6 +20,7 @@ use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
 use crate::core::build_steps::llvm::get_llvm_version;
 use crate::core::build_steps::run::{get_completion_paths, get_help_path};
 use crate::core::build_steps::synthetic_targets::MirOptPanicAbortSyntheticTarget;
+use crate::core::build_steps::test::compiletest::CompiletestMode;
 use crate::core::build_steps::tool::{
     self, RustcPrivateCompilers, SourceType, TEST_FLOAT_PARSE_ALLOW_FEATURES, Tool,
     ToolTargetBuildMode, get_tool_target_compiler,
 @@ -39,6 +43,8 @@ use crate::utils::helpers::{
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
 use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, PathSet, envify};
+mod compiletest;
 /// Runs `cargo test` on various internal tools used by bootstrap.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CrateBootstrap {
 @@ -1085,7 +1091,7 @@ impl Step for RustdocJSNotStd {
         builder.ensure(Compiletest {
             test_compiler: self.compiler,
             target: self.target,
-            mode: "rustdoc-js",
+            mode: CompiletestMode::RustdocJs,
             suite: "rustdoc-js",
             path: "tests/rustdoc-js",
             compare_mode: None,
 @@ -1478,7 +1484,7 @@ macro_rules! test {
                 builder.ensure(Compiletest {
                     test_compiler: self.test_compiler,
                     target: self.target,
-                    mode: $mode,
+                    mode: const { $mode },
                     suite: $suite,
                     path: $path,
                     compare_mode: (const {
 @@ -1493,34 +1499,39 @@ macro_rules! test {
     };
 }
-test!(Ui { path: "tests/ui", mode: "ui", suite: "ui", default: true });
+test!(Ui { path: "tests/ui", mode: CompiletestMode::Ui, suite: "ui", default: true });
-test!(Crashes { path: "tests/crashes", mode: "crashes", suite: "crashes", default: true });
+test!(Crashes {
+    path: "tests/crashes",
+    mode: CompiletestMode::Crashes,
+    suite: "crashes",
+    default: true,
+});
 test!(CodegenLlvm {
     path: "tests/codegen-llvm",
-    mode: "codegen",
+    mode: CompiletestMode::Codegen,
     suite: "codegen-llvm",
     default: true
 });
 test!(CodegenUnits {
     path: "tests/codegen-units",
-    mode: "codegen-units",
+    mode: CompiletestMode::CodegenUnits,
     suite: "codegen-units",
     default: true,
 });
 test!(Incremental {
     path: "tests/incremental",
-    mode: "incremental",
+    mode: CompiletestMode::Incremental,
     suite: "incremental",
     default: true,
 });
 test!(Debuginfo {
     path: "tests/debuginfo",
-    mode: "debuginfo",
+    mode: CompiletestMode::Debuginfo,
     suite: "debuginfo",
     default: true,
     compare_mode: Some("split-dwarf"),
 @@ -1528,7 +1539,7 @@ test!(Debuginfo {
 test!(UiFullDeps {
     path: "tests/ui-fulldeps",
-    mode: "ui",
+    mode: CompiletestMode::Ui,
     suite: "ui-fulldeps",
     default: true,
     IS_HOST: true,
 @@ -1536,14 +1547,14 @@ test!(UiFullDeps {
 test!(Rustdoc {
     path: "tests/rustdoc",
-    mode: "rustdoc",
+    mode: CompiletestMode::Rustdoc,
     suite: "rustdoc",
     default: true,
     IS_HOST: true,
 });
 test!(RustdocUi {
     path: "tests/rustdoc-ui",
-    mode: "ui",
+    mode: CompiletestMode::Ui,
     suite: "rustdoc-ui",
     default: true,
     IS_HOST: true,
 @@ -1551,7 +1562,7 @@ test!(RustdocUi {
 test!(RustdocJson {
     path: "tests/rustdoc-json",
-    mode: "rustdoc-json",
+    mode: CompiletestMode::RustdocJson,
     suite: "rustdoc-json",
     default: true,
     IS_HOST: true,
 @@ -1559,40 +1570,46 @@ test!(RustdocJson {
 test!(Pretty {
     path: "tests/pretty",
-    mode: "pretty",
+    mode: CompiletestMode::Pretty,
     suite: "pretty",
     default: true,
     IS_HOST: true,
 });
-test!(RunMake { path: "tests/run-make", mode: "run-make", suite: "run-make", default: true });
+test!(RunMake {
+    path: "tests/run-make",
+    mode: CompiletestMode::RunMake,
+    suite: "run-make",
+    default: true,
+});
 test!(RunMakeCargo {
     path: "tests/run-make-cargo",
-    mode: "run-make",
+    mode: CompiletestMode::RunMake,
     suite: "run-make-cargo",
     default: true
 });
 test!(AssemblyLlvm {
     path: "tests/assembly-llvm",
-    mode: "assembly",
+    mode: CompiletestMode::Assembly,
     suite: "assembly-llvm",
     default: true
 });
 /// Runs the coverage test suite at `tests/coverage` in some or all of the
 /// coverage test modes.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Coverage {
     pub compiler: Compiler,
     pub target: TargetSelection,
-    pub mode: &'static str,
+    pub(crate) mode: CompiletestMode,
 }
 impl Coverage {
     const PATH: &'static str = "tests/coverage";
     const SUITE: &'static str = "coverage";
-    const ALL_MODES: &[&str] = &["coverage-map", "coverage-run"];
+    const ALL_MODES: &[CompiletestMode] =
+        &[CompiletestMode::CoverageMap, CompiletestMode::CoverageRun];
 }
 impl Step for Coverage {
 @@ -1608,7 +1625,7 @@ impl Step for Coverage {
         // - `./x test coverage-run -- tests/coverage/trivial.rs`
         run = run.suite_path(Self::PATH);
         for mode in Self::ALL_MODES {
-            run = run.alias(mode);
+            run = run.alias(mode.as_str());
         }
         run
     }
 @@ -1631,15 +1648,15 @@ impl Step for Coverage {
         for path in &run.paths {
             match path {
                 PathSet::Set(_) => {
-                    for mode in Self::ALL_MODES {
+                    for &mode in Self::ALL_MODES {
-                        if path.assert_single_path().path == Path::new(mode) {
+                        if path.assert_single_path().path == Path::new(mode.as_str()) {
                             modes.push(mode);
                             break;
                         }
                     }
                 }
                 PathSet::Suite(_) => {
-                    modes.extend(Self::ALL_MODES);
+                    modes.extend_from_slice(Self::ALL_MODES);
                     break;
                 }
             }
 @@ -1647,7 +1664,9 @@ impl Step for Coverage {
         // Skip any modes that were explicitly skipped/excluded on the command-line.
         // FIXME(Zalathar): Integrate this into central skip handling somehow?
-        modes.retain(|mode| !run.builder.config.skip.iter().any(|skip| skip == Path::new(mode)));
+        modes.retain(|mode| {
+            !run.builder.config.skip.iter().any(|skip| skip == Path::new(mode.as_str()))
+        });
         // FIXME(Zalathar): Make these commands skip all coverage tests, as expected:
         // - `./x test --skip=tests`
 @@ -1678,7 +1697,7 @@ impl Step for Coverage {
 test!(CoverageRunRustdoc {
     path: "tests/coverage-run-rustdoc",
-    mode: "coverage-run",
+    mode: CompiletestMode::CoverageRun,
     suite: "coverage-run-rustdoc",
     default: true,
     IS_HOST: true,
 @@ -1712,7 +1731,7 @@ impl Step for MirOpt {
             builder.ensure(Compiletest {
                 test_compiler: self.compiler,
                 target,
-                mode: "mir-opt",
+                mode: CompiletestMode::MirOpt,
                 suite: "mir-opt",
                 path: "tests/mir-opt",
                 compare_mode: None,
 @@ -1755,7 +1774,7 @@ struct Compiletest {
     /// The compiler that we're testing.
     test_compiler: Compiler,
     target: TargetSelection,
-    mode: &'static str,
+    mode: CompiletestMode,
     suite: &'static str,
     path: &'static str,
     compare_mode: Option<&'static str>,
 @@ -1791,7 +1810,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         let suite_path = self.path;
         // Skip codegen tests if they aren't enabled in configuration.
-        if !builder.config.codegen_tests && mode == "codegen" {
+        if !builder.config.codegen_tests && mode == CompiletestMode::Codegen {
             return;
         }
 @@ -1829,7 +1848,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
                 target,
             });
         }
-        if mode == "run-make" {
+        if mode == CompiletestMode::RunMake {
             builder.tool_exe(Tool::RunMakeSupport);
         }
 @@ -1886,7 +1905,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         // suites, `run-make` and `run-make-cargo`. That way, contributors who do not need to run
         // the `run-make` tests that need in-tree cargo do not need to spend time building in-tree
         // cargo.
-        if mode == "run-make" {
+        if mode == CompiletestMode::RunMake {
             // We need to pass the compiler that was used to compile run-make-support,
             // because we have to use the same compiler to compile rmake.rs recipes.
             let stage0_rustc_path = builder.compiler(0, test_compiler.host);
 @@ -1910,17 +1929,18 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         }
         // Avoid depending on rustdoc when we don't need it.
-        if mode == "rustdoc"
+        if matches!(
-            || mode == "run-make"
+            mode,
-            || (mode == "ui" && is_rustdoc)
+            CompiletestMode::RunMake
-            || mode == "rustdoc-js"
+                | CompiletestMode::Rustdoc
-            || mode == "rustdoc-json"
+                | CompiletestMode::RustdocJs
-            || suite == "coverage-run-rustdoc"
+                | CompiletestMode::RustdocJson
+        ) || matches!(suite, "rustdoc-ui" | "coverage-run-rustdoc")
         {
             cmd.arg("--rustdoc-path").arg(builder.rustdoc_for_compiler(test_compiler));
         }
-        if mode == "rustdoc-json" {
+        if mode == CompiletestMode::RustdocJson {
             // Use the stage0 compiler for jsondocck
             let json_compiler = builder.compiler(0, builder.host_target);
             cmd.arg("--jsondocck-path")
 @@ -1930,7 +1950,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
             );
         }
-        if matches!(mode, "coverage-map" | "coverage-run") {
+        if matches!(mode, CompiletestMode::CoverageMap | CompiletestMode::CoverageRun) {
             let coverage_dump = builder.tool_exe(Tool::CoverageDump);
             cmd.arg("--coverage-dump-path").arg(coverage_dump);
         }
 @@ -1957,7 +1977,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cmd.arg("--sysroot-base").arg(sysroot);
         cmd.arg("--suite").arg(suite);
-        cmd.arg("--mode").arg(mode);
+        cmd.arg("--mode").arg(mode.as_str());
         cmd.arg("--target").arg(target.rustc_target_arg());
         cmd.arg("--host").arg(&*test_compiler.host.triple);
         cmd.arg("--llvm-filecheck").arg(builder.llvm_filecheck(builder.config.host_target));
 @@ -2036,7 +2056,7 @@ Please disable assertions with `rust.debug-assertions = false`.
         if let Some(ref nodejs) = builder.config.nodejs {
             cmd.arg("--nodejs").arg(nodejs);
-        } else if mode == "rustdoc-js" {
+        } else if mode == CompiletestMode::RustdocJs {
             panic!("need nodejs to run rustdoc-js suite");
         }
         if builder.config.rust_optimize_tests {
 @@ -2055,7 +2075,7 @@ Please disable assertions with `rust.debug-assertions = false`.
         let mut flags = if is_rustdoc { Vec::new() } else { vec!["-Crpath".to_string()] };
         flags.push(format!(
             "-Cdebuginfo={}",
-            if mode == "codegen" {
+            if mode == CompiletestMode::Codegen {
                 // codegen tests typically check LLVM IR and are sensitive to additional debuginfo.
                 // So do not apply `rust.debuginfo-level-tests` for codegen tests.
                 if builder.config.rust_debuginfo_level_tests
 @@ -2122,7 +2142,7 @@ Please disable assertions with `rust.debug-assertions = false`.
             cmd.arg("--android-cross-path").arg(android_cross_path);
         }
-        if mode == "debuginfo" {
+        if mode == CompiletestMode::Debuginfo {
             if let Some(debuggers::Gdb { gdb }) = debuggers::discover_gdb(builder, android.as_ref())
             {
                 cmd.arg("--gdb").arg(gdb.as_ref());
 @@ -2155,7 +2175,7 @@ Please disable assertions with `rust.debug-assertions = false`.
         // in rustdoc-js mode, allow filters to be rs files or js files.
         // use a late-initialized Vec to avoid cloning for other modes.
         let mut paths_v;
-        if mode == "rustdoc-js" {
+        if mode == CompiletestMode::RustdocJs {
             paths_v = paths.to_vec();
             for p in &mut paths_v {
                 if let Some(ext) = p.extension()
 @@ -2237,7 +2257,9 @@ Please disable assertions with `rust.debug-assertions = false`.
                 cmd.arg("--host-rustcflags").arg(link_llvm);
             }
-            if !builder.config.dry_run() && matches!(mode, "run-make" | "coverage-run") {
+            if !builder.config.dry_run()
+                && matches!(mode, CompiletestMode::RunMake | CompiletestMode::CoverageRun)
+            {
                 // The llvm/bin directory contains many useful cross-platform
                 // tools. Pass the path to run-make tests so they can use them.
                 // (The coverage-run tests also need these tools to process
 @@ -2249,7 +2271,7 @@ Please disable assertions with `rust.debug-assertions = false`.
                 cmd.arg("--llvm-bin-dir").arg(llvm_bin_path);
             }
-            if !builder.config.dry_run() && mode == "run-make" {
+            if !builder.config.dry_run() && mode == CompiletestMode::RunMake {
                 // If LLD is available, add it to the PATH
                 if builder.config.lld_enabled {
                     let lld_install_root =
 @@ -2269,7 +2291,7 @@ Please disable assertions with `rust.debug-assertions = false`.
         // Only pass correct values for these flags for the `run-make` suite as it
         // requires that a C++ compiler was configured which isn't always the case.
-        if !builder.config.dry_run() && mode == "run-make" {
+        if !builder.config.dry_run() && mode == CompiletestMode::RunMake {
             let mut cflags = builder.cc_handled_clags(target, CLang::C);
             cflags.extend(builder.cc_unhandled_cflags(target, GitRepo::Rustc, CLang::C));
             let mut cxxflags = builder.cc_handled_clags(target, CLang::Cxx);
 @@ -2385,7 +2407,7 @@ Please disable assertions with `rust.debug-assertions = false`.
         builder.metrics.begin_test_suite(
             build_helper::metrics::TestSuiteMetadata::Compiletest {
                 suite: suite.into(),
-                mode: mode.into(),
+                mode: mode.to_string(),
                 compare_mode: None,
                 target: self.target.triple.to_string(),
                 host: self.test_compiler.host.triple.to_string(),
 @@ -2408,7 +2430,7 @@ Please disable assertions with `rust.debug-assertions = false`.
             builder.metrics.begin_test_suite(
                 build_helper::metrics::TestSuiteMetadata::Compiletest {
                     suite: suite.into(),
-                    mode: mode.into(),
+                    mode: mode.to_string(),
                     compare_mode: Some(compare_mode.into()),
                     target: self.target.triple.to_string(),
                     host: self.test_compiler.host.triple.to_string(),

src/bootstrap/src/core/build_steps/test/compiletest.rs created+71

...	@@ -0,0 +1,71 @@
1	use std::fmt;
2
3	/// Enum of all the "test modes" understood by compiletest.
4	///
5	/// Some of these mode names happen to overlap with the names of test suite
6	/// directories, but the relationship between modes and suites is not 1:1.
7	/// For example:
8	/// - Mode `ui` is used by suites `tests/ui` and `tests/rustdoc-ui`
9	/// - Suite `tests/coverage` uses modes `coverage-map` and `coverage-run`
10	#[derive(Clone, Copy, PartialEq, Eq, Hash)]
11	pub(crate) enum CompiletestMode {
12	// tidy-alphabetical-start
13	Assembly,
14	Codegen,
15	CodegenUnits,
16	CoverageMap,
17	CoverageRun,
18	Crashes,
19	Debuginfo,
20	Incremental,
21	MirOpt,
22	Pretty,
23	RunMake,
24	Rustdoc,
25	RustdocJs,
26	RustdocJson,
27	Ui,
28	// tidy-alphabetical-end
29	}
30
31	impl CompiletestMode {
32	/// Returns a string representing this mode, which can be passed to
33	/// compiletest via a command-line argument.
34	///
35	/// These mode names must be kept in sync with the ones understood by
36	/// compiletest's `TestMode`, but they change so rarely that doing so
37	/// manually should not be burdensome.
38	pub(crate) const fn as_str(self) -> &'static str {
39	match self {
40	// tidy-alphabetical-start
41	Self::Assembly => "assembly",
42	Self::Codegen => "codegen",
43	Self::CodegenUnits => "codegen-units",
44	Self::CoverageMap => "coverage-map",
45	Self::CoverageRun => "coverage-run",
46	Self::Crashes => "crashes",
47	Self::Debuginfo => "debuginfo",
48	Self::Incremental => "incremental",
49	Self::MirOpt => "mir-opt",
50	Self::Pretty => "pretty",
51	Self::RunMake => "run-make",
52	Self::Rustdoc => "rustdoc",
53	Self::RustdocJs => "rustdoc-js",
54	Self::RustdocJson => "rustdoc-json",
55	Self::Ui => "ui",
56	// tidy-alphabetical-end
57	}
58	}
59	}
60
61	impl fmt::Display for CompiletestMode {
62	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
63	f.write_str(self.as_str())
64	}
65	}
66
67	impl fmt::Debug for CompiletestMode {
68	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
69	<Self as fmt::Display>::fmt(self, f)
70	}
71	}

src/bootstrap/src/core/builder/tests.rs+1-1

...	@@ -346,7 +346,7 @@ fn test_test_coverage() {	...	@@ -346,7 +346,7 @@ fn test_test_coverage() {
346	let mut cache = run_build(&config.paths.clone(), config);	346	let mut cache = run_build(&config.paths.clone(), config);
347		347
348	let modes =	348	let modes =
349	cache.all::<test::Coverage>().iter().map(\|(step, ())\| step.mode).collect::<Vec<_>>();	349	cache.inspect_all_steps_of_type::<test::Coverage, _>(\|step, ()\| step.mode.as_str());
350	assert_eq!(modes, expected);	350	assert_eq!(modes, expected);
351	}	351	}
352	}	352	}

src/bootstrap/src/utils/cache.rs+11-9

...	@@ -270,16 +270,18 @@ impl Cache {	...	@@ -270,16 +270,18 @@ impl Cache {
270		270
271	#[cfg(test)]	271	#[cfg(test)]
272	impl Cache {	272	impl Cache {
273	pub fn all<S: Ord + Step>(&mut self) -> Vec<(S, S::Output)> {	273	pub(crate) fn inspect_all_steps_of_type<S: Step, T: Ord>(
274	let cache = self.cache.get_mut();	274	&self,
275	let type_id = TypeId::of::<S>();	275	map_fn: impl Fn(&S, &S::Output) -> T,
276	let mut v = cache	276	) -> Vec<T> {
277	.remove(&type_id)	277	let cache = self.cache.borrow();
278	.map(\|b\| b.downcast::<HashMap<S, S::Output>>().expect("correct type"))	278	let mut values = cache
279	.map(\|m\| m.into_iter().collect::<Vec<_>>())	279	.get(&TypeId::of::<S>())
		280	.map(\|any\| any.downcast_ref::<HashMap<S, S::Output>>().expect("correct type"))
		281	.map(\|m\| m.iter().map(\|(step, output)\| map_fn(step, output)).collect::<Vec<_>>())
280	.unwrap_or_default();	282	.unwrap_or_default();
281	v.sort_by_key(\|(s, _)\| s.clone());	283	values.sort();
282	v	284	values
283	}	285	}
284		286
285	pub fn contains<S: Step>(&self) -> bool {	287	pub fn contains<S: Step>(&self) -> bool {

src/doc/rustdoc/src/write-documentation/the-doc-attribute.md+2-2

...	@@ -4,8 +4,8 @@ The `#[doc]` attribute lets you control various aspects of how `rustdoc` does	...	@@ -4,8 +4,8 @@ The `#[doc]` attribute lets you control various aspects of how `rustdoc` does
4	its job.	4	its job.
5		5
6	The most basic function of `#[doc]` is to handle the actual documentation	6	The most basic function of `#[doc]` is to handle the actual documentation
7	text. That is, `///` is syntax sugar for `#[doc]`. This means that these two	7	text. That is, `///` is syntax sugar for `#[doc]` (as is `//!` for `#![doc]`).
8	are the same:	8	This means that these two are the same:
9		9
10	```rust,no_run	10	```rust,no_run
11	/// This is a doc comment.	11	/// This is a doc comment.

src/tools/compiletest/src/lib.rs+14-14

 @@ -255,8 +255,17 @@ fn parse_config(args: Vec<String>) -> Config {
         }
     }
-    let target = opt_str2(matches.opt_str("target"));
+    let host = matches.opt_str("host").expect("`--host` must be unconditionally specified");
+    let target = matches.opt_str("target").expect("`--target` must be unconditionally specified");
     let android_cross_path = matches.opt_str("android-cross-path").map(Utf8PathBuf::from);
+    // FIXME: `adb_path` should be an `Option<Utf8PathBuf>`...
+    let adb_path = matches.opt_str("adb-path").map(Utf8PathBuf::from).unwrap_or_default();
+    // FIXME: `adb_test_dir` should be an `Option<Utf8PathBuf>`...
+    let adb_test_dir = matches.opt_str("adb-test-dir").map(Utf8PathBuf::from).unwrap_or_default();
+    let adb_device_status = target.contains("android") && !adb_test_dir.as_str().is_empty();
     // FIXME: `cdb_version` is *derived* from cdb, but it's *not* technically a config!
     let cdb = debuggers::discover_cdb(matches.opt_str("cdb"), &target);
     let cdb_version = cdb.as_deref().and_then(debuggers::query_cdb_version);
 @@ -433,7 +442,7 @@ fn parse_config(args: Vec<String>) -> Config {
         optimize_tests: matches.opt_present("optimize-tests"),
         rust_randomized_layout: matches.opt_present("rust-randomized-layout"),
         target,
-        host: opt_str2(matches.opt_str("host")),
+        host,
         cdb,
         cdb_version,
         gdb,
 @@ -443,11 +452,9 @@ fn parse_config(args: Vec<String>) -> Config {
         llvm_version,
         system_llvm: matches.opt_present("system-llvm"),
         android_cross_path,
-        adb_path: Utf8PathBuf::from(opt_str2(matches.opt_str("adb-path"))),
+        adb_path,
-        adb_test_dir: Utf8PathBuf::from(opt_str2(matches.opt_str("adb-test-dir"))),
+        adb_test_dir,
-        adb_device_status: opt_str2(matches.opt_str("target")).contains("android")
+        adb_device_status,
-            && "(none)" != opt_str2(matches.opt_str("adb-test-dir"))
-            && !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
         verbose: matches.opt_present("verbose"),
         only_modified: matches.opt_present("only-modified"),
         color,
 @@ -493,13 +500,6 @@ fn parse_config(args: Vec<String>) -> Config {
     }
 }
-fn opt_str2(maybestr: Option<String>) -> String {
-    match maybestr {
-        None => "(none)".to_owned(),
-        Some(s) => s,
-    }
-}
 /// Called by `main` after the config has been parsed.
 fn run_tests(config: Arc<Config>) {
     debug!(?config, "run_tests");

tests/pretty/delegation_inline_attribute.pp created+94

...	@@ -0,0 +1,94 @@
1	//@ pretty-compare-only
2	//@ pretty-mode:hir
3	//@ pp-exact:delegation_inline_attribute.pp
4
5	#![allow(incomplete_features)]
6	#![feature(fn_delegation)]
7	#[attr = MacroUse {arguments: UseAll}]
8	extern crate std;
9	#[prelude_import]
10	use ::std::prelude::rust_2015::*;
11
12	mod to_reuse {
13	fn foo(x: usize) -> usize { x }
14	}
15
16	// Check that #[inline(hint)] is added to foo reuse
17	#[attr = Inline(Hint)]
18	fn bar(arg0: _) -> _ { to_reuse::foo(self + 1) }
19
20	trait Trait {
21	fn foo(&self) { }
22	fn foo1(&self) { }
23	fn foo2(&self) { }
24	fn foo3(&self) { }
25	fn foo4(&self) { }
26	}
27
28	impl Trait for u8 { }
29
30	struct S(u8);
31
32	mod to_import {
33	fn check(arg: &'_ u8) -> &'_ u8 { arg }
34	}
35
36	impl Trait for S {
37	// Check that #[inline(hint)] is added to foo reuse
38	#[attr = Inline(Hint)]
39	fn foo(self: _)
40	->
41	_ {
42	{
43	// Check that #[inline(hint)] is added to foo0 reuse inside another reuse
44	#[attr = Inline(Hint)]
45	fn foo0(arg0: _) -> _ { to_reuse::foo(self + 1) }
46
47	// Check that #[inline(hint)] is added when other attributes present in inner reuse
48	#[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
49	#[attr = MustUse]
50	#[attr = Cold]
51	#[attr = Inline(Hint)]
52	fn foo1(arg0: _) -> _ { to_reuse::foo(self / 2) }
53
54	// Check that #[inline(never)] is preserved in inner reuse
55	#[attr = Inline(Never)]
56	fn foo2(arg0: _) -> _ { to_reuse::foo(self / 2) }
57
58	// Check that #[inline(always)] is preserved in inner reuse
59	#[attr = Inline(Always)]
60	fn foo3(arg0: _) -> _ { to_reuse::foo(self / 2) }
61
62	// Check that #[inline(never)] is preserved when there are other attributes in inner reuse
63	#[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
64	#[attr = Inline(Never)]
65	#[attr = MustUse]
66	#[attr = Cold]
67	fn foo4(arg0: _) -> _ { to_reuse::foo(self / 2) }
68	}.foo()
69	}
70
71	// Check that #[inline(hint)] is added when there are other attributes present in trait reuse
72	#[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
73	#[attr = MustUse]
74	#[attr = Cold]
75	#[attr = Inline(Hint)]
76	fn foo1(self: _) -> _ { self.0.foo1() }
77
78	// Check that #[inline(never)] is preserved in trait reuse
79	#[attr = Inline(Never)]
80	fn foo2(self: _) -> _ { self.0.foo2() }
81
82	// Check that #[inline(always)] is preserved in trait reuse
83	#[attr = Inline(Always)]
84	fn foo3(self: _) -> _ { self.0.foo3() }
85
86	// Check that #[inline(never)] is preserved when there are other attributes in trait reuse
87	#[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
88	#[attr = Inline(Never)]
89	#[attr = MustUse]
90	#[attr = Cold]
91	fn foo4(self: _) -> _ { self.0.foo4() }
92	}
93
94	fn main() { }

tests/pretty/delegation_inline_attribute.rs created+104

...	@@ -0,0 +1,104 @@
1	//@ pretty-compare-only
2	//@ pretty-mode:hir
3	//@ pp-exact:delegation_inline_attribute.pp
4
5	#![allow(incomplete_features)]
6	#![feature(fn_delegation)]
7
8	mod to_reuse {
9	pub fn foo(x: usize) -> usize {
10	x
11	}
12	}
13
14	// Check that #[inline(hint)] is added to foo reuse
15	reuse to_reuse::foo as bar {
16	self + 1
17	}
18
19	trait Trait {
20	fn foo(&self) {}
21	fn foo1(&self) {}
22	fn foo2(&self) {}
23	fn foo3(&self) {}
24	fn foo4(&self) {}
25	}
26
27	impl Trait for u8 {}
28
29	struct S(u8);
30
31	mod to_import {
32	pub fn check(arg: &u8) -> &u8 { arg }
33	}
34
35	impl Trait for S {
36	// Check that #[inline(hint)] is added to foo reuse
37	reuse Trait::foo {
38	// Check that #[inline(hint)] is added to foo0 reuse inside another reuse
39	reuse to_reuse::foo as foo0 {
40	self + 1
41	}
42
43	// Check that #[inline(hint)] is added when other attributes present in inner reuse
44	#[cold]
45	#[must_use]
46	#[deprecated]
47	reuse to_reuse::foo as foo1 {
48	self / 2
49	}
50
51	// Check that #[inline(never)] is preserved in inner reuse
52	#[inline(never)]
53	reuse to_reuse::foo as foo2 {
54	self / 2
55	}
56
57	// Check that #[inline(always)] is preserved in inner reuse
58	#[inline(always)]
59	reuse to_reuse::foo as foo3 {
60	self / 2
61	}
62
63	// Check that #[inline(never)] is preserved when there are other attributes in inner reuse
64	#[cold]
65	#[must_use]
66	#[inline(never)]
67	#[deprecated]
68	reuse to_reuse::foo as foo4 {
69	self / 2
70	}
71	}
72
73	// Check that #[inline(hint)] is added when there are other attributes present in trait reuse
74	#[cold]
75	#[must_use]
76	#[deprecated]
77	reuse Trait::foo1 {
78	self.0
79	}
80
81	// Check that #[inline(never)] is preserved in trait reuse
82	#[inline(never)]
83	reuse Trait::foo2 {
84	self.0
85	}
86
87	// Check that #[inline(always)] is preserved in trait reuse
88	#[inline(always)]
89	reuse Trait::foo3 {
90	self.0
91	}
92
93	// Check that #[inline(never)] is preserved when there are other attributes in trait reuse
94	#[cold]
95	#[must_use]
96	#[inline(never)]
97	#[deprecated]
98	reuse Trait::foo4 {
99	self.0
100	}
101	}
102
103	fn main() {
104	}

tests/pretty/hir-delegation.pp+2

...	@@ -12,6 +12,7 @@ use ::std::prelude::rust_2015::*;	...	@@ -12,6 +12,7 @@ use ::std::prelude::rust_2015::*;
12	fn b<C>(e: C) { }	12	fn b<C>(e: C) { }
13		13
14	trait G {	14	trait G {
		15	#[attr = Inline(Hint)]
15	fn b(arg0: _) -> _ { b({ }) }	16	fn b(arg0: _) -> _ { b({ }) }
16	}	17	}
17		18
...	@@ -19,6 +20,7 @@ mod m {	...	@@ -19,6 +20,7 @@ mod m {
19	fn add(a: u32, b: u32) -> u32 { a + b }	20	fn add(a: u32, b: u32) -> u32 { a + b }
20	}	21	}
21		22
		23	#[attr = Inline(Hint)]
22	fn add(arg0: _, arg1: _) -> _ { m::add(arg0, arg1) }	24	fn add(arg0: _, arg1: _) -> _ { m::add(arg0, arg1) }
23		25
24	fn main() { { let _ = add(1, 2); }; }	26	fn main() { { let _ = add(1, 2); }; }

tests/run-make/no-builtins-linker-plugin-lto/main.rs created+3

...	@@ -0,0 +1,3 @@
1	fn main() {
2	no_builtins::foo();
3	}

tests/run-make/no-builtins-linker-plugin-lto/no_builtins.rs created+4

...	@@ -0,0 +1,4 @@
1	#![no_builtins]
2
3	#[inline(never)]
4	pub fn foo() {}

tests/run-make/no-builtins-linker-plugin-lto/rmake.rs created+53

...	@@ -0,0 +1,53 @@
1	//@ only-x86_64-unknown-linux-gnu
2
3	use std::fs;
4	use std::path::Path;
5
6	use run_make_support::{cwd, has_extension, llvm_ar, llvm_bcanalyzer, rust_lib_name, rustc};
7
8	// A regression test for #146133.
9
10	fn main() {
11	// Compile a `#![no_builtins]` rlib crate with `-Clinker-plugin-lto`.
12	// It is acceptable to generate bitcode for rlib, so there is no need to check something.
13	rustc().input("no_builtins.rs").crate_type("rlib").linker_plugin_lto("on").run();
14
15	// Checks that rustc's LTO doesn't emit any bitcode to the linker.
16	let stdout = rustc()
17	.input("main.rs")
18	.extern_("no_builtins", rust_lib_name("no_builtins"))
19	.lto("thin")
20	.print("link-args")
21	.arg("-Csave-temps")
22	.arg("-Clinker-features=-lld")
23	.run()
24	.stdout_utf8();
25	for object in stdout
26	.split_whitespace()
27	.map(\|s\| s.trim_matches('"'))
28	.filter(\|path\| has_extension(path, "rlib") \|\| has_extension(path, "o"))
29	{
30	let object_path = if !fs::exists(object).unwrap() {
31	cwd().join(object)
32	} else {
33	Path::new(object).to_path_buf()
34	};
35	if has_extension(object, "rlib") {
36	let ar_stdout = llvm_ar().arg("t").arg(&object_path).run().stdout_utf8();
37	llvm_ar().extract().arg(&object_path).run();
38	for object in ar_stdout.split_whitespace().filter(\|o\| has_extension(o, "o")) {
39	let object_path = cwd().join(object);
40	not_bitcode(&object_path);
41	}
42	} else {
43	not_bitcode(&object_path);
44	}
45	}
46	}
47
48	fn not_bitcode(object: &Path) {
49	llvm_bcanalyzer()
50	.input(object)
51	.run_fail()
52	.assert_stderr_contains("llvm-bcanalyzer: Invalid record at top-level");
53	}

tests/ui/check-cfg/nested-cfg.rs created+8

...	@@ -0,0 +1,8 @@
1	//@ check-pass
2
3	#[cfg(unknown)] //~ WARN unexpected `cfg` condition name
4	#[cfg(false)]
5	#[cfg(unknown)] // Should not warn
6	fn foo() {}
7
8	fn main() {}

tests/ui/check-cfg/nested-cfg.stderr created+23

...	@@ -0,0 +1,23 @@
1	warning: unexpected `cfg` condition name: `unknown`
2	--> $DIR/nested-cfg.rs:3:7
3	\|
4	LL \| #[cfg(unknown)]
5	\| ^^^^^^^
6	\|
7	= help: expected names are: `FALSE` and `test` and 31 more
8	= help: to expect this configuration use `--check-cfg=cfg(unknown)`
9	= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
10	= note: `#[warn(unexpected_cfgs)]` on by default
11	help: found config with similar value
12	\|
13	LL - #[cfg(unknown)]
14	LL + #[cfg(target_os = "unknown")]
15	\|
16	help: found config with similar value
17	\|
18	LL - #[cfg(unknown)]
19	LL + #[cfg(target_vendor = "unknown")]
20	\|
21
22	warning: 1 warning emitted
23

tests/ui/feature-gates/feature-gate-link_cfg.rs+1-1

...	@@ -1,4 +1,4 @@	...	@@ -1,4 +1,4 @@
1	#[link(name = "foo", cfg(foo))]	1	#[link(name = "foo", cfg(false))]
2	//~^ ERROR: is unstable	2	//~^ ERROR: is unstable
3	extern "C" {}	3	extern "C" {}
4		4

tests/ui/feature-gates/feature-gate-link_cfg.stderr+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	error[E0658]: link cfg is unstable	1	error[E0658]: link cfg is unstable
2	--> $DIR/feature-gate-link_cfg.rs:1:22	2	--> $DIR/feature-gate-link_cfg.rs:1:22
3	\|	3	\|
4	LL \| #[link(name = "foo", cfg(foo))]	4	LL \| #[link(name = "foo", cfg(false))]
5	\| ^^^^^^^^	5	\| ^^^^^^^^^^
6	\|	6	\|
7	= help: add `#![feature(link_cfg)]` to the crate attributes to enable	7	= help: add `#![feature(link_cfg)]` to the crate attributes to enable
8	= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date	8	= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

tests/ui/link-native-libs/link-cfg-works.rs+1-1

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	extern crate link_cfg_works_transitive_dylib;	7	extern crate link_cfg_works_transitive_dylib;
8	extern crate link_cfg_works_transitive_rlib;	8	extern crate link_cfg_works_transitive_rlib;
9		9
10	#[link(name = "foo", cfg(foo))]	10	#[link(name = "foo", cfg(false))]
11	extern "C" {}	11	extern "C" {}
12		12
13	fn main() {}	13	fn main() {}

tests/ui/lint/improper-ctypes/unsafe-binder-basic.rs created+10

...	@@ -0,0 +1,10 @@
1	#![feature(unsafe_binders)]
2	#![expect(incomplete_features)]
3	#![deny(improper_ctypes)]
4
5	extern "C" {
6	fn exit_2(x: unsafe<'a> &'a ());
7	//~^ ERROR `extern` block uses type `unsafe<'a> &'a ()`, which is not FFI-safe
8	}
9
10	fn main() {}

tests/ui/lint/improper-ctypes/unsafe-binder-basic.stderr created+15

...	@@ -0,0 +1,15 @@
1	error: `extern` block uses type `unsafe<'a> &'a ()`, which is not FFI-safe
2	--> $DIR/unsafe-binder-basic.rs:6:18
3	\|
4	LL \| fn exit_2(x: unsafe<'a> &'a ());
5	\| ^^^^^^^^^^^^^^^^^ not FFI-safe
6	\|
7	= note: unsafe binders are incompatible with foreign function interfaces
8	note: the lint level is defined here
9	--> $DIR/unsafe-binder-basic.rs:3:9
10	\|
11	LL \| #![deny(improper_ctypes)]
12	\| ^^^^^^^^^^^^^^^
13
14	error: aborting due to 1 previous error
15

tests/ui/macros/cfg.rs+2-1

...	@@ -2,5 +2,6 @@ fn main() {	...	@@ -2,5 +2,6 @@ fn main() {
2	cfg!(); //~ ERROR macro requires a cfg-pattern	2	cfg!(); //~ ERROR macro requires a cfg-pattern
3	cfg!(123); //~ ERROR malformed `cfg` macro input	3	cfg!(123); //~ ERROR malformed `cfg` macro input
4	cfg!(foo = 123); //~ ERROR malformed `cfg` macro input	4	cfg!(foo = 123); //~ ERROR malformed `cfg` macro input
5	cfg!(foo, bar); //~ ERROR expected 1 cfg-pattern	5	cfg!(false, false); //~ ERROR expected 1 cfg-pattern
		6	cfg!(foo); //~ WARN unexpected `cfg` condition name: `foo`
6	}	7	}

tests/ui/macros/cfg.stderr+14-3

...	@@ -29,9 +29,20 @@ LL \| cfg!(foo = 123);	...	@@ -29,9 +29,20 @@ LL \| cfg!(foo = 123);
29	error: expected 1 cfg-pattern	29	error: expected 1 cfg-pattern
30	--> $DIR/cfg.rs:5:5	30	--> $DIR/cfg.rs:5:5
31	\|	31	\|
32	LL \| cfg!(foo, bar);	32	LL \| cfg!(false, false);
33	\| ^^^^^^^^^^^^^^	33	\| ^^^^^^^^^^^^^^^^^^
34		34
35	error: aborting due to 4 previous errors	35	warning: unexpected `cfg` condition name: `foo`
		36	--> $DIR/cfg.rs:6:10
		37	\|
		38	LL \| cfg!(foo);
		39	\| ^^^
		40	\|
		41	= help: expected names are: `FALSE` and `test` and 31 more
		42	= help: to expect this configuration use `--check-cfg=cfg(foo)`
		43	= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
		44	= note: `#[warn(unexpected_cfgs)]` on by default
		45
		46	error: aborting due to 4 previous errors; 1 warning emitted
36		47
37	For more information about this error, try `rustc --explain E0539`.	48	For more information about this error, try `rustc --explain E0539`.

tests/ui/macros/cfg_select.rs+2

 @@ -89,9 +89,11 @@ cfg_select! {
 cfg_select! {
     a + 1 => {}
     //~^ ERROR expected one of `(`, `::`, `=>`, or `=`, found `+`
+    //~| WARN unexpected `cfg` condition name
 }
 cfg_select! {
     cfg!() => {}
     //~^ ERROR expected one of `(`, `::`, `=>`, or `=`, found `!`
+    //~| WARN unexpected `cfg` condition name
 }

tests/ui/macros/cfg_select.stderr+22-2

...	@@ -60,12 +60,32 @@ LL \| a + 1 => {}	...	@@ -60,12 +60,32 @@ LL \| a + 1 => {}
60	\| ^ expected one of `(`, `::`, `=>`, or `=`	60	\| ^ expected one of `(`, `::`, `=>`, or `=`
61		61
62	error: expected one of `(`, `::`, `=>`, or `=`, found `!`	62	error: expected one of `(`, `::`, `=>`, or `=`, found `!`
63	--> $DIR/cfg_select.rs:95:8	63	--> $DIR/cfg_select.rs:96:8
64	\|	64	\|
65	LL \| cfg!() => {}	65	LL \| cfg!() => {}
66	\| ^ expected one of `(`, `::`, `=>`, or `=`	66	\| ^ expected one of `(`, `::`, `=>`, or `=`
67		67
68	error: aborting due to 9 previous errors; 1 warning emitted	68	warning: unexpected `cfg` condition name: `a`
		69	--> $DIR/cfg_select.rs:90:5
		70	\|
		71	LL \| a + 1 => {}
		72	\| ^ help: found config with similar value: `target_feature = "a"`
		73	\|
		74	= help: expected names are: `FALSE` and `test` and 31 more
		75	= help: to expect this configuration use `--check-cfg=cfg(a)`
		76	= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
		77	= note: `#[warn(unexpected_cfgs)]` on by default
		78
		79	warning: unexpected `cfg` condition name: `cfg`
		80	--> $DIR/cfg_select.rs:96:5
		81	\|
		82	LL \| cfg!() => {}
		83	\| ^^^
		84	\|
		85	= help: to expect this configuration use `--check-cfg=cfg(cfg)`
		86	= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
		87
		88	error: aborting due to 9 previous errors; 3 warnings emitted
69		89
70	Some errors have detailed explanations: E0537, E0539.	90	Some errors have detailed explanations: E0537, E0539.
71	For more information about an error, try `rustc --explain E0537`.	91	For more information about an error, try `rustc --explain E0537`.

tests/ui/privacy/auxiliary/non_exhaustive_with_private.rs created+13

...	@@ -0,0 +1,13 @@
1	// Auxiliary crate for testing non-exhaustive struct with private fields
2
3	#[non_exhaustive]
4	pub struct Foo {
5	pub my_field: u32,
6	private_field: i32,
7	}
8
9	#[non_exhaustive]
10	pub struct Bar {
11	pub my_field: u32,
12	pub missing_field: i32,
13	}

tests/ui/privacy/non-exhaustive-with-private-fields-147513.rs created+17

...	@@ -0,0 +1,17 @@
1	//@ aux-build:non_exhaustive_with_private.rs
2
3	extern crate non_exhaustive_with_private;
4
5	use non_exhaustive_with_private::{Bar, Foo};
6
7	fn main() {
8	let foo = Foo {
9	//~^ ERROR cannot create non-exhaustive struct using struct expression
10	my_field: 10,
11	};
12
13	let bar = Bar {
14	//~^ ERROR cannot create non-exhaustive struct using struct expression
15	my_field: 10,
16	};
17	}

tests/ui/privacy/non-exhaustive-with-private-fields-147513.stderr created+23

...	@@ -0,0 +1,23 @@
1	error[E0639]: cannot create non-exhaustive struct using struct expression
2	--> $DIR/non-exhaustive-with-private-fields-147513.rs:8:15
3	\|
4	LL \| let foo = Foo {
5	\| _______________^
6	LL \| \|
7	LL \| \| my_field: 10,
8	LL \| \| };
9	\| \|_____^
10
11	error[E0639]: cannot create non-exhaustive struct using struct expression
12	--> $DIR/non-exhaustive-with-private-fields-147513.rs:13:15
13	\|
14	LL \| let bar = Bar {
15	\| _______________^
16	LL \| \|
17	LL \| \| my_field: 10,
18	LL \| \| };
19	\| \|_____^
20
21	error: aborting due to 2 previous errors
22
23	For more information about this error, try `rustc --explain E0639`.

triagebot.toml-6

...	@@ -1679,12 +1679,6 @@ days-threshold = 28	...	@@ -1679,12 +1679,6 @@ days-threshold = 28
1679	# Documentation at: https://forge.rust-lang.org/triagebot/issue-links.html	1679	# Documentation at: https://forge.rust-lang.org/triagebot/issue-links.html
1680	[issue-links]	1680	[issue-links]
1681		1681
1682	# Prevents mentions in commits to avoid users being spammed
1683	# Documentation at: https://forge.rust-lang.org/triagebot/no-mentions.html
1684	[no-mentions]
1685	# Subtree update authors can't fix it, no point in warning.
1686	exclude-titles = ["subtree update"]
1687
1688	# Allow members to formally register concerns (`@rustbot concern my concern`)	1682	# Allow members to formally register concerns (`@rustbot concern my concern`)
1689	# Documentation at: https://forge.rust-lang.org/triagebot/concern.html	1683	# Documentation at: https://forge.rust-lang.org/triagebot/concern.html
1690	[concern]	1684	[concern]

author	bors <bors@rust-lang.org> 2025-12-09 08:20:51 UTC
committer	bors <bors@rust-lang.org> 2025-12-09 08:20:51 UTC
log	d5525a73009e2c61b09daa69df79064530bd4dcf
tree	a5ee6c736ec6c1ac5566d9242778e45ce6fc62b7
parent	018d26972e523b8d28f9579056185a1713949dfd
parent	288e97018a5b98959d01af990a50cac960dc9d5f

Auto merge of #149798 - matthiaskrgr:rollup-wjgs9x6, r=matthiaskrgr