Relink don't rebuild: add a baseline, sound implementation that can be incrementally improved

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;
@@ -218,11 +218,11 @@ fn parse_cgu_fields(
     }
 
     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 {
@@ -242,11 +242,7 @@ fn parse_cgu_fields(
     } 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;
         };
 
@@ -256,6 +252,85 @@ fn parse_cgu_fields(
     Some((cfg, module, kind))
 }
 
+fn parse_rdr_fields(cx: &mut AcceptContext<'_, '_>, 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((ident, arg)) = cx.expect_name_value(arg, arg.span(), None) else {
+            continue;
+        };
+
+        let res = match ident.name {
+            sym::cfg => &mut cfg,
+            sym::crate_name => &mut crate_name,
+            _ => {
+                cx.adcx().expected_specific_argument(ident.span, &[sym::cfg, sym::crate_name]);
+                continue;
+            }
+        };
+
+        let Some(str) = arg.value_as_str() else {
+            cx.adcx().expected_string_literal(arg.value_span, Some(arg.value_as_lit()));
+            continue;
+        };
+
+        if res.is_some() {
+            cx.adcx().duplicate_key(ident.span.to(arg.args_span()), ident.name);
+            continue;
+        }
+
+        *res = Some((str, arg.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 AttributeParser for RustcRDRTestAttributeParser {
+    const ATTRIBUTES: AcceptMapping<Self> = &[
+        (
+            &[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: true })
+                }));
+            },
+        ),
+        (
+            &[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: false })
+                }));
+            },
+        ),
+    ];
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
+        Some(AttributeKind::RustcRDRTestAttr(self.items))
+    }
+}
+
 #[derive(Default)]
 pub(crate) struct RustcCguTestAttributeParser {
     items: ThinVec<(Span, CguFields)>,

compiler/rustc_attr_parsing/src/context.rs

@@ -145,6 +145,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_data_structures/src/stable_hasher.rs

@@ -620,4 +620,5 @@ where
 #[derive(Clone, Copy, Hash, Eq, PartialEq, Debug)]
 pub struct HashingControls {
     pub hash_spans: bool,
+    pub hash_spans_as_parentless: bool,
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -762,6 +762,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, StableHash, PrintAttribute)]
+pub struct RDRFields {
+    pub crate_name: Symbol,
+    pub cfg: Symbol,
+    pub changed: bool,
+}
+
 #[derive(Copy, Clone, PartialEq, Debug, PrintAttribute)]
 #[derive(StableHash, Encodable, Decodable)]
 pub enum DivergingFallbackBehavior {
@@ -1520,6 +1527,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

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

compiler/rustc_incremental/src/persist/mod.rs

@@ -7,6 +7,7 @@ mod data;
 mod file_format;
 mod fs;
 mod load;
+mod rdr_hashes;
 mod save;
 mod work_product;
 

compiler/rustc_incremental/src/persist/rdr_hashes.rs

@@ -0,0 +1,88 @@
+use rustc_hir::attrs::RDRFields;
+use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_hir::find_attr;
+use rustc_macros::Diagnostic;
+use rustc_middle::dep_graph::{DepKind, DepNode};
+use rustc_middle::ty::TyCtxt;
+use rustc_span::{Span, Symbol};
+use tracing::debug;
+
+pub(crate) fn check_rdr_test_attrs(tcx: TyCtxt<'_>) {
+    // can't add the attributes without opting into this feature
+    if !tcx.features().rustc_attrs() {
+        return;
+    }
+    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);
+    }
+}
+
+#[derive(Diagnostic)]
+#[diag("found rdr hash attribute but `-Zquery-dep-graph` was not specified")]
+pub(crate) struct MissingQueryDepGraph {
+    #[primary_span]
+    pub span: Span,
+}
+
+/// 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.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
+}
+
+fn assert_dependency_public_hash(tcx: TyCtxt<'_>, span: Span, fields: RDRFields) {
+    if !tcx.sess.opts.unstable_opts.query_dep_graph {
+        tcx.dcx().emit_fatal(MissingQueryDepGraph { span });
+    }
+
+    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 !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)",
+        );
+    }
+}

compiler/rustc_incremental/src/persist/save.rs

@@ -12,7 +12,7 @@ use tracing::debug;
 
 use super::data::*;
 use super::fs::*;
-use super::{clean, file_format, work_product};
+use super::{clean, file_format, rdr_hashes, work_product};
 use crate::assert_dep_graph::assert_dep_graph;
 use crate::errors;
 
@@ -41,6 +41,7 @@ pub(crate) fn save_dep_graph(tcx: TyCtxt<'_>) {
 
         sess.time("assert_dep_graph", || assert_dep_graph(tcx));
         sess.time("check_clean", || clean::check_clean_annotations(tcx));
+        sess.time("check_rdr_hashes", || rdr_hashes::check_rdr_test_attrs(tcx));
 
         par_join(
             move || {

compiler/rustc_metadata/src/creader.rs

@@ -119,7 +119,8 @@ impl<'a> std::fmt::Debug for CrateDump<'a> {
         for (cnum, data) in self.0.iter_crate_data() {
             writeln!(fmt, "  name: {}", data.name())?;
             writeln!(fmt, "  cnum: {cnum}")?;
-            writeln!(fmt, "  hash: {}", data.hash())?;
+            writeln!(fmt, "  private hash: {}", data.private_hash())?;
+            writeln!(fmt, "  public hash:  {}", data.public_hash())?;
             writeln!(fmt, "  reqd: {:?}", data.dep_kind())?;
             writeln!(fmt, "  priv: {:?}", data.is_private_dep())?;
             let CrateSource { dylib, rlib, rmeta, sdylib_interface } = data.source();
@@ -551,19 +552,23 @@ impl CStore {
         }
     }
 
-    fn existing_match(&self, name: Symbol, hash: Option<Svh>) -> Option<CrateNum> {
-        let hash = hash?;
+    fn existing_match(&self, name: Symbol, public_hash: Option<Svh>) -> Option<CrateNum> {
+        let public_hash = public_hash?;
 
         for (cnum, data) in self.iter_crate_data() {
             if data.name() != name {
                 trace!("{} did not match {}", data.name(), name);
                 continue;
             }
 
-            if hash == data.hash() {
+            if public_hash == data.public_hash() {
                 return Some(cnum);
             } else {
-                debug!("actual hash {} did not match expected {}", hash, data.hash());
+                debug!(
+                    "actual public hash {} did not match expected {}",
+                    public_hash,
+                    data.public_hash()
+                );
             }
         }
 
@@ -606,7 +611,15 @@ impl CStore {
 
         let Library { source, metadata } = lib;
         let crate_root = metadata.get_root();
-        let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
+        let host_hash = host_lib.as_ref().map(|lib| {
+            let host_root = lib.metadata.get_root();
+            assert_eq!(
+                host_root.public_hash(),
+                host_root.private_hash(),
+                "Mismatched public and private hash for proc macro!"
+            );
+            host_root.public_hash()
+        });
         let private_dep = self.is_private_dep(&tcx.sess.opts.externs, name, private_dep);
 
         // Claim this crate number and cache it
@@ -877,7 +890,8 @@ impl CStore {
         let root = library.metadata.get_root();
         let mut result = LoadResult::Loaded(library);
         for (cnum, data) in self.iter_crate_data() {
-            if data.name() == root.name() && root.hash() == data.hash() {
+            if data.name() == root.name() && root.public_hash() == data.public_hash() {
+                assert!(root.private_hash() == data.private_hash());
                 assert!(locator.hash.is_none());
                 info!("load success, going to previous cnum: {}", cnum);
                 result = LoadResult::Previous(cnum);