Auto merge of #148802 - ChrisDenton:rollup-h7d8zbf, r=ChrisDenton

Rollup of 9 pull requests

Successful merges:

 - #148480 (Add `Steal::risky_hack_borrow_mut`)
 - #148608 (Add test for --test-builder success path)
 - #148667 (a few small clippy fixes)
 - #148712 (Port `cfg_select!` to the new attribute parsing system)
 - #148760 (rustc_target: hide TargetOptions::vendor)
 - #148775 (Fix a typo in the documentation for the strict_shr function)
 - #148779 (Implement DynSend and DynSync for std::panic::Location.)
 - #148781 ([rustdoc] Remove unneeded `allow(rustc::potential_query_instability)`)
 - #148791 (fix "is_closure_like" doc comment)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_ast_lowering/src/index.rs

@@ -125,9 +125,9 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 }
 
 impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
-    /// Because we want to track parent items and so forth, enable
-    /// deep walking so that we walk nested items in the context of
-    /// their outer items.
+    // Because we want to track parent items and so forth, enable
+    // deep walking so that we walk nested items in the context of
+    // their outer items.
 
     fn visit_nested_item(&mut self, item: ItemId) {
         debug!("visit_nested_item: {:?}", item);

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -0,0 +1,89 @@
+use rustc_ast::token::Token;
+use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{AttrStyle, NodeId, token};
+use rustc_feature::{AttributeTemplate, Features};
+use rustc_hir::AttrPath;
+use rustc_hir::attrs::CfgEntry;
+use rustc_parse::exp;
+use rustc_parse::parser::Parser;
+use rustc_session::Session;
+use rustc_span::{ErrorGuaranteed, Ident, Span};
+
+use crate::parser::MetaItemOrLitParser;
+use crate::{AttributeParser, ParsedDescription, ShouldEmit, parse_cfg_entry};
+
+pub enum CfgSelectPredicate {
+    Cfg(CfgEntry),
+    Wildcard(Token),
+}
+
+#[derive(Default)]
+pub struct CfgSelectBranches {
+    /// All the conditional branches.
+    pub reachable: Vec<(CfgEntry, TokenStream, Span)>,
+    /// The first wildcard `_ => { ... }` branch.
+    pub wildcard: Option<(Token, TokenStream, Span)>,
+    /// All branches after the first wildcard, including further wildcards.
+    /// These branches are kept for formatting.
+    pub unreachable: Vec<(CfgSelectPredicate, TokenStream, Span)>,
+}
+
+pub fn parse_cfg_select(
+    p: &mut Parser<'_>,
+    sess: &Session,
+    features: Option<&Features>,
+    lint_node_id: NodeId,
+) -> Result<CfgSelectBranches, ErrorGuaranteed> {
+    let mut branches = CfgSelectBranches::default();
+
+    while p.token != token::Eof {
+        if p.eat_keyword(exp!(Underscore)) {
+            let underscore = p.prev_token;
+            p.expect(exp!(FatArrow)).map_err(|e| e.emit())?;
+
+            let tts = p.parse_delimited_token_tree().map_err(|e| e.emit())?;
+            let span = underscore.span.to(p.token.span);
+
+            match branches.wildcard {
+                None => branches.wildcard = Some((underscore, tts, span)),
+                Some(_) => {
+                    branches.unreachable.push((CfgSelectPredicate::Wildcard(underscore), tts, span))
+                }
+            }
+        } else {
+            let meta = MetaItemOrLitParser::parse_single(p, ShouldEmit::ErrorsAndLints)
+                .map_err(|diag| diag.emit())?;
+            let cfg_span = meta.span();
+            let cfg = AttributeParser::parse_single_args(
+                sess,
+                cfg_span,
+                cfg_span,
+                AttrStyle::Inner,
+                AttrPath {
+                    segments: vec![Ident::from_str("cfg_select")].into_boxed_slice(),
+                    span: cfg_span,
+                },
+                ParsedDescription::Macro,
+                cfg_span,
+                lint_node_id,
+                features,
+                ShouldEmit::ErrorsAndLints,
+                &meta,
+                parse_cfg_entry,
+                &AttributeTemplate::default(),
+            )?;
+
+            p.expect(exp!(FatArrow)).map_err(|e| e.emit())?;
+
+            let tts = p.parse_delimited_token_tree().map_err(|e| e.emit())?;
+            let span = cfg_span.to(p.token.span);
+
+            match branches.wildcard {
+                None => branches.reachable.push((cfg, tts, span)),
+                Some(_) => branches.unreachable.push((CfgSelectPredicate::Cfg(cfg), tts, span)),
+            }
+        }
+    }
+
+    Ok(branches)
+}

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -33,6 +33,7 @@ pub(crate) mod allow_unstable;
 pub(crate) mod body;
 pub(crate) mod cfg;
 pub(crate) mod cfg_old;
+pub(crate) mod cfg_select;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;
 pub(crate) mod crate_level;

compiler/rustc_attr_parsing/src/lib.rs

@@ -106,6 +106,7 @@ pub use attributes::cfg::{
     CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg, parse_cfg_attr, parse_cfg_entry,
 };
 pub use attributes::cfg_old::*;
+pub use attributes::cfg_select::*;
 pub use attributes::util::{is_builtin_attr, is_doc_alias_attrs_contain_symbol, parse_version};
 pub use context::{Early, Late, OmitDoc, ShouldEmit};
 pub use interface::AttributeParser;

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -1,19 +1,21 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_attr_parsing as attr;
+use rustc_attr_parsing::{
+    CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, ShouldEmit, parse_cfg_select,
+};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
-use rustc_parse::parser::cfg_select::{CfgSelectBranches, CfgSelectPredicate, parse_cfg_select};
 use rustc_span::{Ident, Span, sym};
 
 use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
 
 /// Selects the first arm whose predicate evaluates to true.
 fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
     for (cfg, tt, arm_span) in branches.reachable {
-        if attr::cfg_matches(
-            &cfg,
+        if let EvalConfigResult::True = attr::eval_config_entry(
             &ecx.sess,
+            &cfg,
             ecx.current_expansion.lint_node_id,
-            Some(ecx.ecfg.features),
+            ShouldEmit::ErrorsAndLints,
         ) {
             return Some((tt, arm_span));
         }
@@ -27,37 +29,41 @@ pub(super) fn expand_cfg_select<'cx>(
     sp: Span,
     tts: TokenStream,
 ) -> MacroExpanderResult<'cx> {
-    ExpandResult::Ready(match parse_cfg_select(&mut ecx.new_parser_from_tts(tts)) {
-        Ok(branches) => {
-            if let Some((underscore, _, _)) = branches.wildcard {
-                // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
-                for (predicate, _, _) in &branches.unreachable {
-                    let span = match predicate {
-                        CfgSelectPredicate::Wildcard(underscore) => underscore.span,
-                        CfgSelectPredicate::Cfg(cfg) => cfg.span(),
-                    };
-                    let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
-                    ecx.dcx().emit_warn(err);
+    ExpandResult::Ready(
+        match parse_cfg_select(
+            &mut ecx.new_parser_from_tts(tts),
+            ecx.sess,
+            Some(ecx.ecfg.features),
+            ecx.current_expansion.lint_node_id,
+        ) {
+            Ok(branches) => {
+                if let Some((underscore, _, _)) = branches.wildcard {
+                    // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
+                    for (predicate, _, _) in &branches.unreachable {
+                        let span = match predicate {
+                            CfgSelectPredicate::Wildcard(underscore) => underscore.span,
+                            CfgSelectPredicate::Cfg(cfg) => cfg.span(),
+                        };
+                        let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
+                        ecx.dcx().emit_warn(err);
+                    }
                 }
-            }
 
-            if let Some((tts, arm_span)) = select_arm(ecx, branches) {
-                return ExpandResult::from_tts(
-                    ecx,
-                    tts,
-                    sp,
-                    arm_span,
-                    Ident::with_dummy_span(sym::cfg_select),
-                );
-            } else {
-                // Emit a compiler error when none of the predicates matched.
-                let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
-                DummyResult::any(sp, guar)
+                if let Some((tts, arm_span)) = select_arm(ecx, branches) {
+                    return ExpandResult::from_tts(
+                        ecx,
+                        tts,
+                        sp,
+                        arm_span,
+                        Ident::with_dummy_span(sym::cfg_select),
+                    );
+                } else {
+                    // Emit a compiler error when none of the predicates matched.
+                    let guar = ecx.dcx().emit_err(CfgSelectNoMatches { span: sp });
+                    DummyResult::any(sp, guar)
+                }
             }
-        }
-        Err(err) => {
-            let guar = err.emit();
-            DummyResult::any(sp, guar)
-        }
-    })
+            Err(guar) => DummyResult::any(sp, guar),
+        },
+    )
 }

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -916,8 +916,8 @@ pub(crate) fn codegen_call_with_unwind_action(
 pub(crate) fn lib_call_arg_param(tcx: TyCtxt<'_>, ty: Type, is_signed: bool) -> AbiParam {
     let param = AbiParam::new(ty);
     if ty.is_int() && u64::from(ty.bits()) < tcx.data_layout.pointer_size().bits() {
-        match (&tcx.sess.target.arch, tcx.sess.target.vendor.as_ref()) {
-            (Arch::X86_64, _) | (Arch::AArch64, "apple") => match (ty, is_signed) {
+        match (&tcx.sess.target.arch, tcx.sess.target.is_like_darwin) {
+            (Arch::X86_64, _) | (Arch::AArch64, true) => match (ty, is_signed) {
                 (types::I8 | types::I16, true) => param.sext(),
                 (types::I8 | types::I16, false) => param.uext(),
                 _ => param,

compiler/rustc_codegen_cranelift/src/codegen_f16_f128.rs

@@ -5,7 +5,7 @@ use crate::prelude::*;
 
 pub(crate) fn f16_to_f32(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value {
     let (value, arg_ty) =
-        if fx.tcx.sess.target.vendor == "apple" && fx.tcx.sess.target.arch == Arch::X86_64 {
+        if fx.tcx.sess.target.is_like_darwin && fx.tcx.sess.target.arch == Arch::X86_64 {
             (
                 fx.bcx.ins().bitcast(types::I16, MemFlags::new(), value),
                 lib_call_arg_param(fx.tcx, types::I16, false),
@@ -22,8 +22,7 @@ fn f16_to_f64(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value {
 }
 
 pub(crate) fn f32_to_f16(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value {
-    let ret_ty = if fx.tcx.sess.target.vendor == "apple" && fx.tcx.sess.target.arch == Arch::X86_64
-    {
+    let ret_ty = if fx.tcx.sess.target.is_like_darwin && fx.tcx.sess.target.arch == Arch::X86_64 {
         types::I16
     } else {
         types::F16
@@ -38,8 +37,7 @@ pub(crate) fn f32_to_f16(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value
 }
 
 fn f64_to_f16(fx: &mut FunctionCx<'_, '_, '_>, value: Value) -> Value {
-    let ret_ty = if fx.tcx.sess.target.vendor == "apple" && fx.tcx.sess.target.arch == Arch::X86_64
-    {
+    let ret_ty = if fx.tcx.sess.target.is_like_darwin && fx.tcx.sess.target.arch == Arch::X86_64 {
         types::I16
     } else {
         types::F16

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1819,7 +1819,7 @@ fn self_contained_components(
                 LinkSelfContainedDefault::InferredForMusl => sess.crt_static(Some(crate_type)),
                 LinkSelfContainedDefault::InferredForMingw => {
                     sess.host == sess.target
-                        && sess.target.vendor != "uwp"
+                        && sess.target.abi != "uwp"
                         && detect_self_contained_mingw(sess, linker)
                 }
             }

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -83,7 +83,7 @@ pub(crate) fn get_linker<'a>(
     // To comply with the Windows App Certification Kit,
     // MSVC needs to link with the Store versions of the runtime libraries (vcruntime, msvcrt, etc).
     let t = &sess.target;
-    if matches!(flavor, LinkerFlavor::Msvc(..)) && t.vendor == "uwp" {
+    if matches!(flavor, LinkerFlavor::Msvc(..)) && t.abi == "uwp" {
         if let Some(ref tool) = msvc_tool {
             let original_path = tool.path();
             if let Some(root_lib_path) = original_path.ancestors().nth(4) {
@@ -134,7 +134,7 @@ pub(crate) fn get_linker<'a>(
 
     // FIXME: Move `/LIBPATH` addition for uwp targets from the linker construction
     // to the linker args construction.
-    assert!(cmd.get_args().is_empty() || sess.target.vendor == "uwp");
+    assert!(cmd.get_args().is_empty() || sess.target.abi == "uwp");
     match flavor {
         LinkerFlavor::Unix(Cc::No) if sess.target.os == "l4re" => {
             Box::new(L4Bender::new(cmd, sess)) as Box<dyn Linker>

compiler/rustc_codegen_ssa/src/common.rs

@@ -171,7 +171,7 @@ pub fn asm_const_to_str<'tcx>(
 }
 
 pub fn is_mingw_gnu_toolchain(target: &Target) -> bool {
-    target.vendor == "pc" && target.os == "windows" && target.env == "gnu" && target.abi.is_empty()
+    target.os == "windows" && target.env == "gnu" && target.abi.is_empty()
 }
 
 pub fn i686_decorated_name(