Relink don't rebuild: improve public api hashing using an rmeta reachability graph

Cargo.lock

@@ -4417,6 +4417,7 @@ dependencies = [
  "rustc_expand",
  "rustc_feature",
  "rustc_fs_util",
+ "rustc_hashes",
  "rustc_hir",
  "rustc_hir_pretty",
  "rustc_index",

compiler/rustc_attr_ir/src/data_structures.rs

@@ -72,6 +72,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, Encodable, Decodable, Debug, StableHash, PrintAttribute)]
 pub enum InlineAttr {
     None,
@@ -1389,6 +1396,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_attr_ir/src/encode_cross_crate.rs

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

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -4,8 +4,8 @@ use rustc_ast::{LitIntType, LitKind, MetaItemLit};
 use rustc_attr_ir::lang_items::LangItem;
 use rustc_attr_ir::target::GenericParamKind;
 use rustc_attr_ir::{
-    BorrowckGraphvizFormatKind, CguFields, CguKind, RustcCleanAttribute, RustcCleanQueries,
-    RustcMirKind,
+    BorrowckGraphvizFormatKind, CguFields, CguKind, RDRFields, RustcCleanAttribute,
+    RustcCleanQueries, RustcMirKind,
 };
 use rustc_data_structures::fx::FxHashMap;
 use rustc_feature::AttributeStability;
@@ -15,8 +15,8 @@ use super::prelude::*;
 use super::util::parse_single_integer;
 use crate::diagnostics;
 use crate::diagnostics::{
-    AttributeRequiresOpt, CguFieldsMissing, RustcScalableVectorCountOutOfRange,
-    UnknownExternLangItem, UnknownLangItem,
+    AttributeRequiresOpt, FieldsMissing, RustcScalableVectorCountOutOfRange, UnknownExternLangItem,
+    UnknownLangItem,
 };
 
 pub(crate) struct RustcMainParser;
@@ -256,11 +256,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 {
@@ -280,11 +280,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;
         };
 
@@ -294,6 +290,87 @@ 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 = "...""#]),
+            unstable!(rustc_attrs),
+            |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 = "...""#]),
+            unstable!(rustc_attrs),
+            |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

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

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -949,7 +949,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_gcc/src/callee.rs

@@ -107,6 +107,7 @@ pub fn get_fn<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, instance: Instance<'tcx>)
                 if !(cx.tcx.sess.opts.share_generics()
                     || tcx.codegen_instance_attrs(instance.def).inline
                         == rustc_hir::attrs::InlineAttr::Never)
+                    || tcx.sess.opts.unstable_opts.public_api_hash
                 {
                     // When not sharing generics, all instances are in the same
                     // crate and have hidden visibility.

compiler/rustc_codegen_llvm/src/callee.rs

@@ -100,6 +100,7 @@ pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'t
             if !(cx.tcx.sess.opts.share_generics()
                 || tcx.codegen_instance_attrs(instance.def).inline
                     == rustc_hir::attrs::InlineAttr::Never)
+                || tcx.sess.opts.unstable_opts.public_api_hash
             {
                 // When not sharing generics, all instances are in the same
                 // crate and have hidden visibility.

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -177,8 +177,14 @@ fn is_reachable_non_generic_provider_local(tcx: TyCtxt<'_>, def_id: LocalDefId)
     }
 }
 
-fn is_reachable_non_generic_provider_extern(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
-    tcx.reachable_non_generics(def_id.krate).contains_key(&def_id)
+fn is_reachable_non_generic_with_export_level_c_provider(
+    tcx: TyCtxt<'_>,
+    def_id: LocalDefId,
+) -> bool {
+    match tcx.reachable_non_generics(LOCAL_CRATE).get(&def_id.to_def_id()) {
+        Some(SymbolExportInfo { level: SymbolExportLevel::C, .. }) => true,
+        _ => false,
+    }
 }
 
 fn exported_non_generic_symbols_provider_local<'tcx>(
@@ -389,6 +395,7 @@ fn exported_generic_symbols_provider_local<'tcx>(
             if !item_is_offload && !tcx.sess.opts.share_generics() {
                 if tcx.codegen_fn_attrs(mono_item.def_id()).inline
                     == rustc_hir::attrs::InlineAttr::Never
+                    && !tcx.sess.opts.unstable_opts.public_api_hash
                 {
                     // this is OK, we explicitly allow sharing inline(never) across crates even
                     // without share-generics.
@@ -598,7 +605,8 @@ pub(crate) fn provide(providers: &mut Providers) {
     providers.queries.upstream_drop_glue_for = upstream_drop_glue_for_provider;
     providers.queries.upstream_async_drop_glue_for = upstream_async_drop_glue_for_provider;
     providers.queries.wasm_import_module_map = wasm_import_module_map;
-    providers.extern_queries.is_reachable_non_generic = is_reachable_non_generic_provider_extern;
+    providers.queries.is_reachable_non_generic_with_export_level_c =
+        is_reachable_non_generic_with_export_level_c_provider;
     providers.extern_queries.upstream_monomorphizations_for =
         upstream_monomorphizations_for_provider;
 }

compiler/rustc_feature/src/builtin_attrs.rs

@@ -401,6 +401,8 @@ pub static BUILTIN_ATTRIBUTES: &[Symbol] = &[
     sym::rustc_partition_reused,
     sym::rustc_partition_codegened,
     sym::rustc_expected_cgu_reuse,
+    sym::rustc_public_hash_changed,
+    sym::rustc_public_hash_unchanged,
     sym::rustc_dump_symbol_name,
     sym::rustc_dump_def_path,
     sym::rustc_mir,

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -49,7 +49,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::diagnostics::feature_err;
-use rustc_span::def_id::ModId;
+use rustc_span::def_id::VisibilityModId;
 use rustc_span::{DUMMY_SP, Ident, Span, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{self, FulfillmentError};
@@ -123,7 +123,7 @@ pub enum RegionInferReason<'a> {
 pub struct InherentAssocCandidate {
     pub impl_: DefId,
     pub assoc_item: DefId,
-    pub scope: ModId,
+    pub scope: VisibilityModId,
 }
 
 pub struct ResolvedStructPath<'tcx> {
@@ -1810,7 +1810,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         ident: Ident,
         assoc_tag: ty::AssocTag,
         scope: DefId,
-    ) -> Option<(ty::AssocItem, /*scope*/ ModId)> {
+    ) -> Option<(ty::AssocItem, /*scope*/ VisibilityModId)> {
         let tcx = self.tcx();
 
         let (ident, def_scope) = tcx.adjust_ident_and_get_scope(ident, scope, self.item_def_id());
@@ -1830,7 +1830,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         &self,
         item_def_id: DefId,
         ident: Ident,
-        scope: ModId,
+        scope: VisibilityModId,
         block: HirId,
         span: Span,
     ) {

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,91 @@
+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<'_>) {
+    if !tcx.sess.opts.unstable_opts.query_dep_graph {
+        return;
+    }
+    // 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)",
+        );
+    }
+}