Rollup of 12 pull requests

Cargo.lock

@@ -4805,7 +4805,6 @@ name = "rustdoc-gui-test"
 version = "0.1.0"
 dependencies = [
  "build_helper",
- "camino",
  "compiletest",
  "getopts",
  "walkdir",

compiler/rustc_ast/src/token.rs

@@ -881,11 +881,11 @@ impl Token {
     }
 
     pub fn is_qpath_start(&self) -> bool {
-        self == &Lt || self == &Shl
+        matches!(self.kind, Lt | Shl)
     }
 
     pub fn is_path_start(&self) -> bool {
-        self == &PathSep
+        self.kind == PathSep
             || self.is_qpath_start()
             || matches!(self.is_metavar_seq(), Some(MetaVarKind::Path))
             || self.is_path_segment_keyword()

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -6,6 +6,7 @@ use crate::session_diagnostics::{
     NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass, NullOnObjcSelector,
     ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
 };
+use crate::target_checking::Policy::AllowSilent;
 
 pub(crate) struct OptimizeParser;
 
@@ -362,6 +363,8 @@ impl<S: Stage> NoArgsAttributeParser<S> for NoMangleParser {
         Allow(Target::Static),
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::TraitImpl)),
+        AllowSilent(Target::Const), // Handled in the `InvalidNoMangleItems` pass
+        Error(Target::Closure),
     ]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoMangle;
 }

compiler/rustc_attr_parsing/src/target_checking.rs

@@ -31,7 +31,9 @@ impl AllowedTargets {
     pub(crate) fn is_allowed(&self, target: Target) -> AllowedResult {
         match self {
             AllowedTargets::AllowList(list) => {
-                if list.contains(&Policy::Allow(target)) {
+                if list.contains(&Policy::Allow(target))
+                    || list.contains(&Policy::AllowSilent(target))
+                {
                     AllowedResult::Allowed
                 } else if list.contains(&Policy::Warn(target)) {
                     AllowedResult::Warn
@@ -40,7 +42,9 @@ impl AllowedTargets {
                 }
             }
             AllowedTargets::AllowListWarnRest(list) => {
-                if list.contains(&Policy::Allow(target)) {
+                if list.contains(&Policy::Allow(target))
+                    || list.contains(&Policy::AllowSilent(target))
+                {
                     AllowedResult::Allowed
                 } else if list.contains(&Policy::Error(target)) {
                     AllowedResult::Error
@@ -61,17 +65,26 @@ impl AllowedTargets {
         .iter()
         .filter_map(|target| match target {
             Policy::Allow(target) => Some(*target),
+            Policy::AllowSilent(_) => None, // Not listed in possible targets
             Policy::Warn(_) => None,
             Policy::Error(_) => None,
         })
         .collect()
     }
 }
 
+/// This policy determines what diagnostics should be emitted based on the `Target` of the attribute.
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Policy {
+    /// A target that is allowed.
     Allow(Target),
+    /// A target that is allowed and not listed in the possible targets.
+    /// This is useful if the target is checked elsewhere.
+    AllowSilent(Target),
+    /// Emits a FCW on this target.
+    /// This is useful if the target was previously allowed but should not be.
     Warn(Target),
+    /// Emits an error on this target.
     Error(Target),
 }
 

compiler/rustc_builtin_macros/src/asm.rs

@@ -368,7 +368,7 @@ fn expand_preparsed_asm(
         if args.options.contains(ast::InlineAsmOptions::RAW) {
             template.push(ast::InlineAsmTemplatePiece::String(template_str.to_string().into()));
             let template_num_lines = 1 + template_str.matches('\n').count();
-            line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
+            line_spans.extend(std::iter::repeat_n(template_sp, template_num_lines));
             continue;
         }
 
@@ -523,7 +523,7 @@ fn expand_preparsed_asm(
 
         if parser.line_spans.is_empty() {
             let template_num_lines = 1 + template_str.matches('\n').count();
-            line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
+            line_spans.extend(std::iter::repeat_n(template_sp, template_num_lines));
         } else {
             line_spans.extend(
                 parser

compiler/rustc_builtin_macros/src/format.rs

@@ -69,35 +69,26 @@ struct MacroInput {
 /// Ok((fmtstr, parsed arguments))
 /// ```
 fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a, MacroInput> {
-    let mut args = FormatArguments::new();
-
     let mut p = ecx.new_parser_from_tts(tts);
 
-    if p.token == token::Eof {
-        return Err(ecx.dcx().create_err(errors::FormatRequiresString { span: sp }));
-    }
-
-    let first_token = &p.token;
-
-    let fmtstr = if let token::Literal(lit) = first_token.kind
-        && matches!(lit.kind, token::Str | token::StrRaw(_))
-    {
+    // parse the format string
+    let fmtstr = match p.token.kind {
+        token::Eof => return Err(ecx.dcx().create_err(errors::FormatRequiresString { span: sp })),
         // This allows us to properly handle cases when the first comma
         // after the format string is mistakenly replaced with any operator,
         // which cause the expression parser to eat too much tokens.
-        p.parse_literal_maybe_minus()?
-    } else {
+        token::Literal(token::Lit { kind: token::Str | token::StrRaw(_), .. }) => {
+            p.parse_literal_maybe_minus()?
+        }
         // Otherwise, we fall back to the expression parser.
-        p.parse_expr()?
+        _ => p.parse_expr()?,
     };
 
-    // Only allow implicit captures to be used when the argument is a direct literal
-    // instead of a macro expanding to one.
-    let is_direct_literal = matches!(fmtstr.kind, ExprKind::Lit(_));
-
+    // parse comma FormatArgument pairs
+    let mut args = FormatArguments::new();
     let mut first = true;
-
     while p.token != token::Eof {
+        // parse a comma, or else report an error
         if !p.eat(exp!(Comma)) {
             if first {
                 p.clear_expected_token_types();
@@ -120,9 +111,11 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
             }
         }
         first = false;
+        // accept a trailing comma
         if p.token == token::Eof {
             break;
-        } // accept trailing commas
+        }
+        // parse a FormatArgument
         match p.token.ident() {
             Some((ident, _)) if p.look_ahead(1, |t| *t == token::Eq) => {
                 p.bump();
@@ -156,6 +149,10 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
             }
         }
     }
+
+    // Only allow implicit captures for direct literals
+    let is_direct_literal = matches!(fmtstr.kind, ExprKind::Lit(_));
+
     Ok(MacroInput { fmtstr, args, is_direct_literal })
 }
 

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -318,7 +318,7 @@ fn data_id_for_static(
         let mut data = DataDescription::new();
         data.set_align(align);
         let data_gv = module.declare_data_in_data(data_id, &mut data);
-        data.define(std::iter::repeat(0).take(pointer_ty(tcx).bytes() as usize).collect());
+        data.define(std::iter::repeat_n(0, pointer_ty(tcx).bytes() as usize).collect());
         data.write_data_addr(0, data_gv, 0);
         match module.define_data(ref_data_id, &data) {
             // Every time the static is referenced there will be another definition of this global,

compiler/rustc_codegen_llvm/src/consts.rs

@@ -240,11 +240,13 @@ impl<'ll> CodegenCx<'ll, '_> {
                 let gv = self.define_global(&name, self.val_ty(cv)).unwrap_or_else(|| {
                     bug!("symbol `{}` is already defined", name);
                 });
-                llvm::set_linkage(gv, llvm::Linkage::PrivateLinkage);
                 gv
             }
-            _ => self.define_private_global(self.val_ty(cv)),
+            _ => self.define_global("", self.val_ty(cv)).unwrap_or_else(|| {
+                bug!("anonymous global symbol is already defined");
+            }),
         };
+        llvm::set_linkage(gv, llvm::Linkage::PrivateLinkage);
         llvm::set_initializer(gv, cv);
         set_global_alignment(self, gv, align);
         llvm::set_unnamed_address(gv, llvm::UnnamedAddr::Global);

compiler/rustc_codegen_llvm/src/declare.rs

@@ -230,13 +230,6 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
         }
     }
 
-    /// Declare a private global
-    ///
-    /// Use this function when you intend to define a global without a name.
-    pub(crate) fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
-        unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod(), ty) }
-    }
-
     /// Gets declared value by name.
     pub(crate) fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
         debug!("get_declared_value(name={:?})", name);

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1955,7 +1955,6 @@ unsafe extern "C" {
         NameLen: size_t,
         T: &'a Type,
     ) -> &'a Value;
-    pub(crate) fn LLVMRustInsertPrivateGlobal<'a>(M: &'a Module, T: &'a Type) -> &'a Value;
     pub(crate) fn LLVMRustGetNamedValue(
         M: &Module,
         Name: *const c_char,

compiler/rustc_codegen_ssa/messages.ftl

@@ -223,8 +223,6 @@ codegen_ssa_multiple_main_functions = entry symbol `main` declared multiple time
 
 codegen_ssa_no_field = no field `{$name}`
 
-codegen_ssa_no_mangle_nameless = `#[no_mangle]` cannot be used on {$definition} as it has no name
-
 codegen_ssa_no_module_named =
     no module named `{$user_path}` (mangled: {$cgu_name}). available modules: {$cgu_names}
 

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -19,7 +19,6 @@ use rustc_span::{Ident, Span, sym};
 use rustc_target::spec::SanitizerSet;
 
 use crate::errors;
-use crate::errors::NoMangleNameless;
 use crate::target_features::{
     check_target_feature_trait_unsafe, check_tied_features, from_target_feature_attr,
 };
@@ -182,14 +181,10 @@ fn process_builtin_attrs(
                     if tcx.opt_item_name(did.to_def_id()).is_some() {
                         codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
                     } else {
-                        tcx.dcx().emit_err(NoMangleNameless {
-                            span: *attr_span,
-                            definition: format!(
-                                "{} {}",
-                                tcx.def_descr_article(did.to_def_id()),
-                                tcx.def_descr(did.to_def_id())
-                            ),
-                        });
+                        tcx.dcx().span_delayed_bug(
+                            *attr_span,
+                            "no_mangle should be on a named function",
+                        );
                     }
                 }
                 AttributeKind::Optimize(optimize, _) => codegen_fn_attrs.optimize = *optimize,

compiler/rustc_codegen_ssa/src/errors.rs

@@ -1284,14 +1284,6 @@ impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_
     }
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_ssa_no_mangle_nameless)]
-pub(crate) struct NoMangleNameless {
-    #[primary_span]
-    pub span: Span,
-    pub definition: String,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_ssa_feature_not_valid)]
 pub(crate) struct FeatureNotValid<'a> {

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -110,7 +110,7 @@ pub fn get_span_and_frames<'tcx>(
             if frame.times < 3 {
                 let times = frame.times;
                 frame.times = 0;
-                frames.extend(std::iter::repeat(frame).take(times as usize));
+                frames.extend(std::iter::repeat_n(frame, times as usize));
             } else {
                 frames.push(frame);
             }