rdr: add comments indicating that public api hashing must be updated when changing some rmeta encoder functions

Author: susitsm

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -727,6 +727,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
         _ = stat!("def-ids", || self.encode_def_ids(hcx));
 
+        // When changed, make sure to update the hashing in `hash_crate_root_public_api`
         let interpret_alloc_index = stat!("interpret-alloc-index", || {
             let mut interpret_alloc_index = Vec::new();
             let mut n = 0;
@@ -767,6 +768,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             stat!("exportable-items", || self.encode_stable_order_of_exportable_impls());
 
         // Encode exported symbols info. This is prefetched in `encode_metadata`.
+        // When changed, make sure to update the hashing in `hash_crate_root_public_api`
         let (exported_non_generic_symbols, exported_generic_symbols) =
             stat!("exported-symbols", || {
                 (
@@ -790,7 +792,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // `SourceFiles` we actually need to encode.
         let source_map =
             stat!("source-map", || self.encode_source_map(hcx, &mut public_api_hasher));
+        // When changed, make sure to update the hashing in `hash_crate_root_public_api`
         let target_modifiers = stat!("target-modifiers", || self.encode_target_modifiers());
+        // When changed, make sure to update the hashing in `hash_crate_root_public_api`
         let denied_partial_mitigations = stat!("denied-partial-mitigations", || self
             .encode_enabled_denied_partial_mitigations());
 
@@ -1759,6 +1763,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         }
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_externally_implementable_items(&mut self) -> LazyArray<EiiMapEncodedKeyValue> {
         empty_proc_macro!(self);
         let externally_implementable_items = self.tcx.externally_implementable_items(LOCAL_CRATE);
@@ -2080,12 +2085,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         record!(self.tables.macro_definition[def_id.to_def_id()] <- &*macro_def.body, hcx);
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_native_libraries(&mut self) -> LazyArray<NativeLib> {
         empty_proc_macro!(self);
         let used_libraries = self.tcx.native_libraries(LOCAL_CRATE);
         self.lazy_array(used_libraries.iter())
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_foreign_modules(&mut self) -> LazyArray<ForeignModule> {
         empty_proc_macro!(self);
         let foreign_modules = self.tcx.foreign_modules(LOCAL_CRATE);
@@ -2223,6 +2230,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         }
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_debugger_visualizers(&mut self) -> LazyArray<DebuggerVisualizerFile> {
         empty_proc_macro!(self);
         self.lazy_array(
@@ -2237,6 +2245,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         )
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_crate_deps(&mut self) -> LazyArray<CrateDep> {
         empty_proc_macro!(self);
 
@@ -2277,6 +2286,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(lib_features.to_sorted_vec())
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_stability_implications(&mut self) -> LazyArray<(Symbol, Symbol)> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
@@ -2285,13 +2295,15 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(sorted.into_iter().map(|(k, v)| (*k, *v)))
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_diagnostic_items(&mut self) -> LazyArray<(Symbol, DefIndex)> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
         let diagnostic_items = &tcx.diagnostic_items(LOCAL_CRATE).name_to_id;
         self.lazy_array(diagnostic_items.iter().map(|(&name, def_id)| (name, def_id.index)))
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_lang_items(&mut self) -> LazyArray<(DefIndex, LangItem)> {
         empty_proc_macro!(self);
         let lang_items = self.tcx.lang_items().iter();
@@ -2300,12 +2312,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         }))
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_lang_items_missing(&mut self) -> LazyArray<LangItem> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
         self.lazy_array(&tcx.lang_items().missing)
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_stripped_cfg_items(&mut self) -> LazyArray<StrippedCfgItem<DefIndex>> {
         self.lazy_array(
             self.tcx
@@ -2315,12 +2329,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         )
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_traits(&mut self) -> LazyArray<DefIndex> {
         empty_proc_macro!(self);
         self.lazy_array(self.tcx.traits(LOCAL_CRATE).iter().map(|def_id| def_id.index))
     }
 
     /// Encodes an index, mapping each trait to its (local) implementations.
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     #[instrument(level = "debug", skip(self, hcx))]
     fn encode_impls(
         &mut self,
@@ -2391,6 +2407,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     }
 
     #[instrument(level = "debug", skip(self))]
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_incoherent_impls(&mut self) -> LazyArray<IncoherentImpls> {
         empty_proc_macro!(self);
         let tcx = self.tcx;
@@ -2409,11 +2426,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(&all_impls)
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_exportable_items(&mut self) -> LazyArray<DefIndex> {
         empty_proc_macro!(self);
         self.lazy_array(self.tcx.exportable_items(LOCAL_CRATE).iter().map(|def_id| def_id.index))
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_stable_order_of_exportable_impls(&mut self) -> LazyArray<(DefIndex, usize)> {
         empty_proc_macro!(self);
         let stable_order_of_exportable_impls =
@@ -2438,6 +2457,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(exported_symbols.iter().cloned())
     }
 
+    // When changed, make sure to update the hashing in `hash_crate_root_public_api`
     fn encode_dylib_dependency_formats(&mut self) -> LazyArray<Option<LinkagePreference>> {
         empty_proc_macro!(self);
         if let Some(arr) = dylib_dependency_formats(self.tcx) {