Auto merge of #148404 - matthiaskrgr:rollup-o61qhjw, r=matthiaskrgr

Rollup of 9 pull requests

Successful merges:

 - #147137 (Mention crate being analyzed in query description)
 - #147155 (arm-linux.md: various fixes/improvements)
 - #147642 (Miscellaneous const-generics-related fixes)
 - #147806 (Ignore test-dashboard related files)
 - #147947 (Implement `strip_circumfix` lib feature)
 - #148346 (Change cfg_trace, cfg_attr_trace symbol values)
 - #148348 (dangling ptr lint cleanup)
 - #148393 (Remove `tests/run-make/fmt-write-bloat/`)
 - #148400 (Better warning message for crate type unsupported by codegen backend)

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

Author: bors

.gitignore

@@ -90,6 +90,10 @@ node_modules
 ## Rustdoc GUI tests
 tests/rustdoc-gui/src/**.lock
 
+## Test dashboard
+.citool-cache/
+test-dashboard/
+
 ## direnv
 /.envrc
 /.direnv/

compiler/rustc_driver_impl/src/lib.rs

@@ -686,8 +686,12 @@ fn print_crate_info(
                 };
                 let t_outputs = rustc_interface::util::build_output_filenames(attrs, sess);
                 let crate_name = passes::get_crate_name(sess, attrs);
-                let crate_types =
-                    collect_crate_types(sess, &codegen_backend.supported_crate_types(sess), attrs);
+                let crate_types = collect_crate_types(
+                    sess,
+                    &codegen_backend.supported_crate_types(sess),
+                    codegen_backend.name(),
+                    attrs,
+                );
                 for &style in &crate_types {
                     let fname = rustc_session::output::filename_for_input(
                         sess, style, crate_name, &t_outputs,

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -77,20 +77,6 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         // stable enough and does not need a feature gate anymore.
         Node::AnonConst(_) => {
             let parent_did = tcx.parent(def_id.to_def_id());
-
-            // We don't do this unconditionally because the `DefId` parent of an anon const
-            // might be an implicitly created closure during `async fn` desugaring. This would
-            // have the wrong generics.
-            //
-            // i.e. `async fn foo<'a>() { let a = [(); { 1 + 2 }]; bar().await() }`
-            // would implicitly have a closure in its body that would be the parent of
-            // the `{ 1 + 2 }` anon const. This closure's generics is simply a witness
-            // instead of `['a]`.
-            let parent_did = if let DefKind::AnonConst = tcx.def_kind(parent_did) {
-                parent_did
-            } else {
-                tcx.hir_get_parent_item(hir_id).to_def_id()
-            };
             debug!(?parent_did);
 
             let mut in_param_ty = false;

compiler/rustc_interface/src/passes.rs

@@ -929,6 +929,7 @@ pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
     let crate_types = collect_crate_types(
         sess,
         &compiler.codegen_backend.supported_crate_types(sess),
+        compiler.codegen_backend.name(),
         &pre_configured_attrs,
     );
     let stable_crate_id = StableCrateId::new(

compiler/rustc_lint/messages.ftl

@@ -193,11 +193,11 @@ lint_confusable_identifier_pair = found both `{$existing_sym}` and `{$sym}` as i
     .current_use = this identifier can be confused with `{$existing_sym}`
     .other_use = other identifier used here
 
-lint_dangling_pointers_from_locals = a dangling pointer will be produced because the local variable `{$local_var_name}` will be dropped
-    .ret_ty = return type of the {$fn_kind} is `{$ret_ty}`
-    .local_var = `{$local_var_name}` is part the {$fn_kind} and will be dropped at the end of the {$fn_kind}
+lint_dangling_pointers_from_locals = {$fn_kind} returns a dangling pointer to dropped local variable `{$local_var_name}`
+    .ret_ty = return type is `{$ret_ty}`
+    .local_var = local variable `{$local_var_name}` is dropped at the end of the {$fn_kind}
     .created_at = dangling pointer created here
-    .note = pointers do not have a lifetime; after returning, the `{$local_var_ty}` will be deallocated at the end of the {$fn_kind} because nothing is referencing it as far as the type system is concerned
+    .note = a dangling pointer is safe, but dereferencing one is undefined behavior
 
 lint_dangling_pointers_from_temporaries = a dangling pointer will be produced because the temporary `{$ty}` will be dropped
     .label_ptr = this pointer will immediately be invalid

compiler/rustc_middle/src/query/mod.rs

@@ -397,7 +397,10 @@ rustc_queries! {
     /// The root query triggering all analysis passes like typeck or borrowck.
     query analysis(key: ()) {
         eval_always
-        desc { "running analysis passes on this crate" }
+        desc { |tcx|
+            "running analysis passes on crate `{}`",
+            tcx.crate_name(LOCAL_CRATE),
+        }
     }
 
     /// This query checks the fulfillment of collected lint expectations.

compiler/rustc_mir_build/src/thir/constant.rs

@@ -58,8 +58,12 @@ pub(crate) fn lit_to_const<'tcx>(
         (ast::LitKind::Byte(n), ty::Uint(ty::UintTy::U8)) => {
             ty::ValTree::from_scalar_int(tcx, n.into())
         }
-        (ast::LitKind::CStr(byte_sym, _), ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::CStr)) => {
-            ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str())
+        (ast::LitKind::CStr(byte_sym, _), ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::CStr)) =>
+        {
+            // A CStr is a newtype around a byte slice, so we create the inner slice here.
+            // We need a branch for each "level" of the data structure.
+            let bytes = ty::ValTree::from_raw_bytes(tcx, byte_sym.as_byte_str());
+            ty::ValTree::from_branches(tcx, [bytes])
         }
         (ast::LitKind::Int(n, _), ty::Uint(ui)) if !neg => {
             let scalar_int = trunc(n.get(), *ui);

compiler/rustc_session/messages.ftl

@@ -140,6 +140,9 @@ session_unleashed_feature_help_unnamed = skipping check that does not even have
 
 session_unstable_virtual_function_elimination = `-Zvirtual-function-elimination` requires `-Clto`
 
+session_unsupported_crate_type_for_codegen_backend =
+    dropping unsupported crate type `{$crate_type}` for codegen backend `{$codegen_backend}`
+
 session_unsupported_crate_type_for_target =
     dropping unsupported crate type `{$crate_type}` for target `{$target_triple}`
 

compiler/rustc_session/src/errors.rs

@@ -371,6 +371,13 @@ struct BinaryFloatLiteralNotSupported {
     span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(session_unsupported_crate_type_for_codegen_backend)]
+pub(crate) struct UnsupportedCrateTypeForCodegenBackend {
+    pub(crate) crate_type: CrateType,
+    pub(crate) codegen_backend: &'static str,
+}
+
 #[derive(Diagnostic)]
 #[diag(session_unsupported_crate_type_for_target)]
 pub(crate) struct UnsupportedCrateTypeForTarget<'a> {

compiler/rustc_session/src/output.rs

@@ -177,6 +177,7 @@ pub fn categorize_crate_type(s: Symbol) -> Option<CrateType> {
 pub fn collect_crate_types(
     session: &Session,
     backend_crate_types: &[CrateType],
+    codegen_backend_name: &'static str,
     attrs: &[ast::Attribute],
 ) -> Vec<CrateType> {
     // If we're generating a test executable, then ignore all other output
@@ -223,17 +224,18 @@ pub fn collect_crate_types(
     }
 
     base.retain(|crate_type| {
-        if invalid_output_for_target(session, *crate_type)
-            || !backend_crate_types.contains(crate_type)
-        {
-            // FIXME provide a better warning for the case where the codegen
-            // backend doesn't support it once cargo doesn't hard code this
-            // warning message.
+        if invalid_output_for_target(session, *crate_type) {
             session.dcx().emit_warn(errors::UnsupportedCrateTypeForTarget {
                 crate_type: *crate_type,
                 target_triple: &session.opts.target_triple,
             });
             false
+        } else if !backend_crate_types.contains(crate_type) {
+            session.dcx().emit_warn(errors::UnsupportedCrateTypeForCodegenBackend {
+                crate_type: *crate_type,
+                codegen_backend: codegen_backend_name,
+            });
+            false
         } else {
             true
         }