rdr: add rustc_public_hash_unchanged and rustc_public_hash_changed attributes for testing

Author: susitsm

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -4,15 +4,15 @@ use rustc_ast::{LitIntType, LitKind, MetaItemLit};
 use rustc_hir::LangItem;
 use rustc_hir::attrs::{
     BorrowckGraphvizFormatKind, CguFields, CguKind, DivergingBlockBehavior,
-    DivergingFallbackBehavior, RustcCleanAttribute, RustcCleanQueries, RustcMirKind,
+    DivergingFallbackBehavior, RDRFields, RustcCleanAttribute, RustcCleanQueries, RustcMirKind,
 };
 use rustc_span::Symbol;
 
 use super::prelude::*;
 use super::util::parse_single_integer;
 use crate::errors;
 use crate::session_diagnostics::{
-    AttributeRequiresOpt, CguFieldsMissing, RustcScalableVectorCountOutOfRange, UnknownLangItem,
+    AttributeRequiresOpt, FieldsMissing, RustcScalableVectorCountOutOfRange, UnknownLangItem,
 };
 
 pub(crate) struct RustcMainParser;
@@ -250,11 +250,11 @@ fn parse_cgu_fields<S: Stage>(
     }
 
     let Some((cfg, _)) = cfg else {
-        cx.emit_err(CguFieldsMissing { span: args.span, name: &cx.attr_path, field: sym::cfg });
+        cx.emit_err(FieldsMissing { span: args.span, name: &cx.attr_path, field: sym::cfg });
         return None;
     };
     let Some((module, _)) = module else {
-        cx.emit_err(CguFieldsMissing { span: args.span, name: &cx.attr_path, field: sym::module });
+        cx.emit_err(FieldsMissing { span: args.span, name: &cx.attr_path, field: sym::module });
         return None;
     };
     let kind = if let Some((kind, span)) = kind {
@@ -274,11 +274,7 @@ fn parse_cgu_fields<S: Stage>(
     } else {
         // return None so that an unwrap for the attributes that need it is ok.
         if accepts_kind {
-            cx.emit_err(CguFieldsMissing {
-                span: args.span,
-                name: &cx.attr_path,
-                field: sym::kind,
-            });
+            cx.emit_err(FieldsMissing { span: args.span, name: &cx.attr_path, field: sym::kind });
             return None;
         };
 
@@ -288,6 +284,95 @@ fn parse_cgu_fields<S: Stage>(
     Some((cfg, module, kind))
 }
 
+fn parse_rdr_fields<S: Stage>(
+    cx: &mut AcceptContext<'_, '_, S>,
+    args: &ArgParser,
+) -> Option<(Symbol, Symbol)> {
+    let args = cx.expect_list(args, cx.attr_span)?;
+
+    let mut cfg = None::<(Symbol, Span)>;
+    let mut crate_name = None::<(Symbol, Span)>;
+
+    for arg in args.mixed() {
+        let Some(arg) = arg.meta_item() else {
+            cx.adcx().expected_name_value(args.span, None);
+            continue;
+        };
+
+        let res = match arg.ident().map(|i| i.name) {
+            Some(sym::cfg) => &mut cfg,
+            Some(sym::crate_name) => &mut crate_name,
+            _ => {
+                cx.adcx()
+                    .expected_specific_argument(arg.path().span(), &[sym::cfg, sym::crate_name]);
+                continue;
+            }
+        };
+
+        let Some(i) = arg.args().name_value() else {
+            cx.adcx().expected_name_value(arg.span(), None);
+            continue;
+        };
+
+        let Some(str) = i.value_as_str() else {
+            cx.adcx().expected_string_literal(i.value_span, Some(i.value_as_lit()));
+            continue;
+        };
+
+        if res.is_some() {
+            cx.adcx().duplicate_key(arg.span(), arg.ident().unwrap().name);
+            continue;
+        }
+
+        *res = Some((str, i.value_span));
+    }
+
+    let Some((cfg, _)) = cfg else {
+        cx.emit_err(FieldsMissing { span: args.span, name: &cx.attr_path, field: sym::cfg });
+        return None;
+    };
+    let Some((crate_name, _)) = crate_name else {
+        cx.emit_err(FieldsMissing { span: args.span, name: &cx.attr_path, field: sym::crate_name });
+        return None;
+    };
+
+    Some((cfg, crate_name))
+}
+
+#[derive(Default)]
+pub(crate) struct RustcRDRTestAttributeParser {
+    items: ThinVec<(Span, RDRFields)>,
+}
+
+impl<S: Stage> AttributeParser<S> for RustcRDRTestAttributeParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[
+        (
+            &[sym::rustc_public_hash_changed],
+            template!(List: &[r#"cfg = "...", crate_name = "...""#]),
+            |this, cx, args| {
+                this.items.extend(parse_rdr_fields(cx, args).map(|(cfg, crate_name)| {
+                    (cx.attr_span, RDRFields { cfg, crate_name, changed: false })
+                }));
+            },
+        ),
+        (
+            &[sym::rustc_public_hash_unchanged],
+            template!(List: &[r#"cfg = "...", crate_name = "...""#]),
+            |this, cx, args| {
+                this.items.extend(parse_rdr_fields(cx, args).map(|(cfg, crate_name)| {
+                    (cx.attr_span, RDRFields { cfg, crate_name, changed: true })
+                }));
+            },
+        ),
+    ];
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        Some(AttributeKind::RustcRDRTestAttr(self.items))
+    }
+}
+
 #[derive(Default)]
 pub(crate) struct RustcCguTestAttributeParser {
     items: ThinVec<(Span, CguFields)>,

compiler/rustc_attr_parsing/src/context.rs

@@ -164,6 +164,7 @@ attribute_parsers!(
         RustcAlignParser,
         RustcAlignStaticParser,
         RustcCguTestAttributeParser,
+        RustcRDRTestAttributeParser,
         StabilityParser,
         UsedParser,
         // tidy-alphabetical-end

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -50,7 +50,7 @@ pub(crate) struct DocAliasStartEnd<'a> {
 
 #[derive(Diagnostic)]
 #[diag("`#[{$name})]` is missing a `{$field}` argument")]
-pub(crate) struct CguFieldsMissing<'a> {
+pub(crate) struct FieldsMissing<'a> {
     #[primary_span]
     pub span: Span,
     pub name: &'a AttrPath,

compiler/rustc_codegen_ssa/src/assert_module_sources.rs

@@ -28,23 +28,80 @@ use std::fmt;
 
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::{DiagArgValue, IntoDiagArg};
-use rustc_hir::attrs::{CguFields, CguKind};
+use rustc_hir::attrs::{CguFields, CguKind, RDRFields};
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::{self as hir, find_attr};
+use rustc_middle::dep_graph::{DepKind, DepNode};
 use rustc_middle::mono::CodegenUnitNameBuilder;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::{Span, Symbol};
 use tracing::debug;
 
 use crate::errors;
+fn check_rdr_test_attrs(tcx: TyCtxt<'_>) {
+    for &(span, fields) in
+        find_attr!(tcx.hir_attrs(rustc_hir::CRATE_HIR_ID), RustcRDRTestAttr(e) => e)
+            .into_iter()
+            .flatten()
+    {
+        assert_dependency_public_hash(tcx, span, fields);
+    }
+}
+
+fn assert_dependency_public_hash(tcx: TyCtxt<'_>, span: Span, fields: RDRFields) {
+    let crate_num = tcx
+        .crates(())
+        .iter()
+        .copied()
+        .find(|&cnum| tcx.crate_name(cnum).as_str() == fields.crate_name.as_str())
+        .unwrap_or_else(|| {
+            tcx.dcx().span_fatal(
+                span,
+                format!("crate `{}` not found in dependencies", fields.crate_name),
+            )
+        });
+    if crate_num == LOCAL_CRATE {
+        tcx.dcx().span_fatal(span, "expected the name of a dependency crate");
+    }
+
+    if !tcx.sess.opts.unstable_opts.query_dep_graph {
+        tcx.dcx().emit_fatal(errors::MissingQueryDepGraph { span });
+    }
+
+    if !check_config(tcx, fields.cfg) {
+        debug!("check_attr: config does not match, ignoring attr");
+        return;
+    }
+
+    let green = !fields.changed;
+    let dep_node = DepNode::construct(tcx, DepKind::public_api_hash, &crate_num);
+    let is_green = tcx.dep_graph.is_green(&dep_node);
+    let is_red = tcx.dep_graph.is_red(&dep_node);
+    if !is_red && !is_green {
+        tcx.dcx().span_fatal(span, "dependency color is neither red or green!");
+    }
+
+    if green && !is_green {
+        tcx.dcx().span_fatal(
+            span,
+            "expected dependency to be unchanged (green) but it was changed (red)",
+        );
+    } else if !green && is_green {
+        tcx.dcx().span_fatal(
+            span,
+            "expected dependency to have changed (red) but it was unchanged (green)",
+        );
+    }
+}
 
 #[allow(missing_docs)]
 pub fn assert_module_sources(tcx: TyCtxt<'_>, set_reuse: &dyn Fn(&mut CguReuseTracker)) {
     tcx.dep_graph.with_ignore(|| {
         if tcx.sess.opts.incremental.is_none() {
             return;
         }
+        check_rdr_test_attrs(tcx);
 
         let available_cgus = tcx
             .collect_and_partition_mono_items(())
@@ -111,7 +168,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
                 self.tcx.dcx().emit_fatal(errors::MissingQueryDepGraph { span });
             }
 
-            if !self.check_config(cfg) {
+            if !check_config(self.tcx, cfg) {
                 debug!("check_attr: config does not match, ignoring attr");
                 return;
             }
@@ -167,19 +224,19 @@ impl<'tcx> AssertModuleSource<'tcx> {
             );
         }
     }
+}
 
-    /// Scan for a `cfg="foo"` attribute and check whether we have a
-    /// cfg flag called `foo`.
-    fn check_config(&self, value: Symbol) -> bool {
-        let config = &self.tcx.sess.psess.config;
-        debug!("check_config(config={:?}, value={:?})", config, value);
-        if config.iter().any(|&(name, _)| name == value) {
-            debug!("check_config: matched");
-            return true;
-        }
-        debug!("check_config: no match found");
-        false
+/// Scan for a `cfg="foo"` attribute and check whether we have a
+/// cfg flag called `foo`.
+fn check_config(tcx: TyCtxt<'_>, value: Symbol) -> bool {
+    let config = &tcx.sess.psess.config;
+    debug!("check_config(config={:?}, value={:?})", config, value);
+    if config.iter().any(|&(name, _)| name == value) {
+        debug!("check_config: matched");
+        return true;
     }
+    debug!("check_config: no match found");
+    false
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]

compiler/rustc_feature/src/builtin_attrs.rs

@@ -772,6 +772,8 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     rustc_attr!(TEST, rustc_partition_reused),
     rustc_attr!(TEST, rustc_partition_codegened),
     rustc_attr!(TEST, rustc_expected_cgu_reuse),
+    rustc_attr!(TEST, rustc_public_hash_changed),
+    rustc_attr!(TEST, rustc_public_hash_unchanged),
     rustc_attr!(TEST, rustc_dump_symbol_name),
     rustc_attr!(TEST, rustc_dump_def_path),
     rustc_attr!(TEST, rustc_mir),

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -69,6 +69,13 @@ pub enum CguFields {
     ExpectedCguReuse { cfg: Symbol, module: Symbol, kind: CguKind },
 }
 
+#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, PrintAttribute)]
+pub struct RDRFields {
+    pub crate_name: Symbol,
+    pub cfg: Symbol,
+    pub changed: bool,
+}
+
 #[derive(Copy, Clone, PartialEq, Debug, PrintAttribute)]
 #[derive(HashStable_Generic, Encodable, Decodable)]
 pub enum DivergingFallbackBehavior {
@@ -1558,6 +1565,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_pub_transparent]` (used by the `repr_transparent_external_private_fields` lint).
     RustcPubTransparent(Span),
 
+    /// Represents `#[rustc_public_hash_changed]` and `#[rustc_public_hash_unchanged]`.
+    RustcRDRTestAttr(ThinVec<(Span, RDRFields)>),
+
     /// Represents `#[rustc_reallocator]`
     RustcReallocator,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -177,6 +177,7 @@ impl AttributeKind {
             RustcPreserveUbChecks => No,
             RustcProcMacroDecls => No,
             RustcPubTransparent(..) => Yes,
+            RustcRDRTestAttr(..) => No,
             RustcReallocator => No,
             RustcRegions => No,
             RustcReservationImpl(..) => Yes,

compiler/rustc_passes/src/check_attr.rs

@@ -341,6 +341,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RustcPassIndirectlyInNonRusticAbis(..)
                     | AttributeKind::RustcPreserveUbChecks
                     | AttributeKind::RustcProcMacroDecls
+                    | AttributeKind::RustcRDRTestAttr(..)
                     | AttributeKind::RustcReallocator
                     | AttributeKind::RustcRegions
                     | AttributeKind::RustcReservationImpl(..)

compiler/rustc_query_system/src/ich/mod.rs

@@ -0,0 +1,21 @@
+//! ICH - Incremental Compilation Hash
+
+use rustc_span::{Symbol, sym};
+
+pub use self::hcx::StableHashingContext;
+
+mod hcx;
+mod impls_syntax;
+
+pub const IGNORED_ATTRIBUTES: &[Symbol] = &[
+    sym::cfg_trace, // FIXME should this really be ignored?
+    sym::rustc_if_this_changed,
+    sym::rustc_then_this_would_need,
+    sym::rustc_dirty,
+    sym::rustc_clean,
+    sym::rustc_partition_reused,
+    sym::rustc_partition_codegened,
+    sym::rustc_expected_cgu_reuse,
+    sym::rustc_public_hash_unchanged,
+    sym::rustc_public_hash_changed,
+];

compiler/rustc_span/src/symbol.rs

@@ -1794,6 +1794,8 @@ symbols! {
         rustc_proc_macro_decls,
         rustc_promotable,
         rustc_pub_transparent,
+        rustc_public_hash_changed,
+        rustc_public_hash_unchanged,
         rustc_reallocator,
         rustc_regions,
         rustc_reservation_impl,