rdr: rename -Z separate_spans to -Z stable_crate_hash

Author: davidbarsky

compiler/rustc_interface/src/queries.rs

@@ -64,7 +64,7 @@ impl Linker {
         {
             let spans_path = path.with_extension("spans");
             let mut files: Vec<(&'static str, &Path)> = vec![("rmeta", path)];
-            if sess.opts.unstable_opts.separate_spans && spans_path.exists() {
+            if sess.opts.unstable_opts.stable_crate_hash && spans_path.exists() {
                 files.push(("spans", &spans_path));
             }
             if let Some((id, product)) =

compiler/rustc_metadata/src/creader.rs

@@ -631,10 +631,10 @@ impl CStore {
             None
         };
 
-        let has_separate_spans = crate_root.has_separate_spans();
+        let has_stable_crate_hash = crate_root.has_stable_crate_hash();
         let crate_name = crate_root.name();
 
-        if has_separate_spans && source.spans.is_none() {
+        if has_stable_crate_hash && source.spans.is_none() {
             return Err(CrateError::MissingSpanFile(crate_name, "file not found".to_string()));
         }
 
@@ -652,7 +652,7 @@ impl CStore {
             host_hash,
         );
 
-        if has_separate_spans {
+        if has_stable_crate_hash {
             crate_metadata
                 .ensure_span_file_loaded()
                 .map_err(|err| CrateError::MissingSpanFile(crate_name, err))?;

compiler/rustc_metadata/src/fs.rs

@@ -87,9 +87,9 @@ pub fn encode_and_write_metadata(tcx: TyCtxt<'_>) -> EncodedMetadata {
         None
     };
 
-    // When -Z separate-spans is enabled, encode spans to a separate .spans file
+    // When -Z stable-crate-hash is enabled, encode spans to a separate .spans file
     let spans_tmp_filename = if let Some(required_source_files) = required_source_files
-        && tcx.sess.opts.unstable_opts.separate_spans
+        && tcx.sess.opts.unstable_opts.stable_crate_hash
     {
         let spans_tmp_filename = metadata_tmpdir.as_ref().join("lib.spans");
         encode_spans(tcx, &spans_tmp_filename, tcx.crate_hash(LOCAL_CRATE), required_source_files);
@@ -107,12 +107,12 @@ pub fn encode_and_write_metadata(tcx: TyCtxt<'_>) -> EncodedMetadata {
     let (metadata_filename, metadata_tmpdir) = if need_metadata_file {
         let filename = match out_filename {
             OutFileName::Real(ref path) => {
-                // RDR optimization: when -Z separate-spans is enabled, skip writing
+                // RDR optimization: when -Z stable-crate-hash is enabled, skip writing
                 // the .rmeta file if its content hash (SVH) hasn't changed. This
                 // preserves the file's mtime, preventing cargo from rebuilding
                 // dependent crates when only span positions changed.
                 let new_hash = tcx.crate_hash(LOCAL_CRATE);
-                let skip_write = tcx.sess.opts.unstable_opts.separate_spans
+                let skip_write = tcx.sess.opts.unstable_opts.stable_crate_hash
                     && read_existing_metadata_hash(path).is_some_and(|old_hash| {
                         let matches = old_hash == new_hash;
                         if matches {

compiler/rustc_metadata/src/locator.rs

@@ -961,7 +961,7 @@ fn get_rmeta_metadata_section<'a, 'p>(filename: &'p Path) -> Result<OwnedSlice,
     Ok(slice_owned(mmap, Deref::deref))
 }
 
-/// Loads a span metadata file (.spans) that accompanies rmeta files compiled with -Z separate_spans.
+/// Loads a span metadata file (.spans) that accompanies rmeta files compiled with -Z stable-crate-hash.
 pub(crate) fn get_span_metadata_section(filename: &Path) -> Result<SpanBlob, String> {
     // mmap the file, because only a small fraction of it is read.
     let file = std::fs::File::open(filename)

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -229,7 +229,7 @@ struct ImportedSourceFile {
 /// - `Some(imported)` means successfully imported
 ///
 /// Note: Import failures now indicate a bug (either corrupted metadata or
-/// the crate was compiled with `-Z separate-spans` but the `.spans` file
+/// the crate was compiled with `-Z stable-crate-hash` but the `.spans` file
 /// is missing, which should have been caught at crate load time).
 
 /// Decode context used when we just have a blob of metadata from which we have to decode a header
@@ -846,7 +846,7 @@ impl<'a, 'tcx> Decodable<MetadataDecodeContext<'a, 'tcx>> for SpanData {
         };
 
         // Source file should always be available - missing files are caught at crate load time
-        // for crates compiled with -Z separate-spans, and should never happen otherwise.
+        // for crates compiled with -Z stable-crate-hash, and should never happen otherwise.
         let source_file = source_file.expect("source file should be available");
 
         // Make sure our span is well-formed.
@@ -1181,8 +1181,8 @@ impl CrateRoot {
         self.target_modifiers.decode(metadata)
     }
 
-    pub(crate) fn has_separate_spans(&self) -> bool {
-        self.has_separate_spans
+    pub(crate) fn has_stable_crate_hash(&self) -> bool {
+        self.has_stable_crate_hash
     }
 }
 
@@ -1871,7 +1871,7 @@ impl<'a> CrateMetadataRef<'a> {
     /// Returns `None` if the source file index doesn't exist in the source map table
     /// (sparse table entry). This can happen when iterating through all indices.
     ///
-    /// Note: For crates compiled with `-Z separate-spans`, missing `.spans` files
+    /// Note: For crates compiled with `-Z stable-crate-hash`, missing `.spans` files
     /// are detected and errored at crate load time, before this function is called.
     fn imported_source_file(
         self,
@@ -1986,10 +1986,11 @@ impl<'a> CrateMetadataRef<'a> {
             return Some(cached.clone());
         }
 
-        let source_file_to_import = if self.root.has_separate_spans() {
-            let span_data = self.cdata.span_file_data().expect(
-                "span file should be loaded for crate compiled with -Z separate-spans",
-            );
+        let source_file_to_import = if self.root.has_stable_crate_hash() {
+            let span_data = self
+                .cdata
+                .span_file_data()
+                .expect("span file should be loaded for crate compiled with -Z stable-crate-hash");
             span_data
                 .source_map
                 .get_from_span_blob(&span_data.blob, source_file_index)
@@ -2009,7 +2010,7 @@ impl<'a> CrateMetadataRef<'a> {
         // Return None for sparse table entries. This can happen when:
         // - Searching through all source file indices (some may be empty)
         //
-        // Note: For crates compiled with -Z separate-spans, missing .spans files
+        // Note: For crates compiled with -Z stable-crate-hash, missing .spans files
         // are now detected and errored at crate load time, so that case no longer
         // reaches here.
         let Some(source_file_to_import) = source_file_to_import else {

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -673,8 +673,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     }
 
     /// Encode source map using the provided set of required source files.
-    /// This is used both for rmeta (when separate_spans is disabled) and
-    /// for the span file (when separate_spans is enabled).
+    /// This is used both for rmeta (when stable_crate_hash is disabled) and
+    /// for the span file (when stable_crate_hash is enabled).
     fn encode_source_map_with(
         &mut self,
         required_source_files: FxIndexSet<usize>,
@@ -853,9 +853,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
         // Encode source_map. This needs to be done last, because encoding `Span`s tells us which
         // `SourceFiles` we actually need to encode.
-        // When separate_spans is enabled, source_map goes in the span file instead.
+        // When stable_crate_hash is enabled, source_map goes in the span file instead.
         let source_map = stat!("source-map", || {
-            if self.tcx.sess.opts.unstable_opts.separate_spans {
+            if self.tcx.sess.opts.unstable_opts.stable_crate_hash {
                 // Don't encode source_map in rmeta; it will be in the .spans file.
                 // Keep required_source_files for the span file encoding.
                 TableBuilder::default().encode(&mut self.opaque)
@@ -924,7 +924,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 expn_hashes,
                 def_path_hash_map,
                 specialization_enabled_in: tcx.specialization_enabled_in(LOCAL_CRATE),
-                has_separate_spans: tcx.sess.opts.unstable_opts.separate_spans,
+                has_stable_crate_hash: tcx.sess.opts.unstable_opts.stable_crate_hash,
             })
         });
 
@@ -2650,7 +2650,7 @@ impl<D: Decoder> Decodable<D> for EncodedMetadata {
 }
 
 /// Encodes crate metadata to the given path.
-/// Returns the set of required source files if `-Z separate_spans` is enabled,
+/// Returns the set of required source files if `-Z stable-crate-hash` is enabled,
 /// which is needed for encoding the span file.
 #[instrument(level = "trace", skip(tcx))]
 pub fn encode_metadata(
@@ -2697,7 +2697,7 @@ pub fn encode_metadata(
             Ok(_) => {}
             Err(err) => tcx.dcx().emit_fatal(FailCreateFileEncoder { err }),
         };
-        if tcx.sess.opts.unstable_opts.separate_spans
+        if tcx.sess.opts.unstable_opts.stable_crate_hash
             && let Some(saved_spans) = work_product.saved_files.get("spans")
         {
             let span_source =
@@ -2778,7 +2778,7 @@ pub fn encode_spans(
 }
 
 /// Encodes metadata with standard header.
-/// Returns the required_source_files if separate_spans is enabled (for span file encoding).
+/// Returns the required_source_files if stable_crate_hash is enabled (for span file encoding).
 fn with_encode_metadata_header(
     tcx: TyCtxt<'_>,
     path: &Path,
@@ -2832,8 +2832,12 @@ fn with_encode_metadata_header(
         tcx.dcx().emit_fatal(FailWriteFile { path: ecx.opaque.path(), err });
     }
 
-    // Return required_source_files if separate_spans is enabled (for span file encoding)
-    if tcx.sess.opts.unstable_opts.separate_spans { ecx.required_source_files.take() } else { None }
+    // Return required_source_files if stable_crate_hash is enabled (for span file encoding)
+    if tcx.sess.opts.unstable_opts.stable_crate_hash {
+        ecx.required_source_files.take()
+    } else {
+        None
+    }
 }
 
 fn with_encode_span_header(

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -344,9 +344,9 @@ pub(crate) struct CrateRoot {
 
     specialization_enabled_in: bool,
 
-    /// Whether this crate was compiled with `-Z separate-spans`.
+    /// Whether this crate was compiled with `-Z stable-crate-hash`.
     /// If true, span data is in a separate `.spans` file, not in this rmeta.
-    has_separate_spans: bool,
+    has_stable_crate_hash: bool,
 }
 
 /// On-disk representation of `DefId`.

compiler/rustc_session/src/cstore.rs

@@ -25,7 +25,7 @@ pub struct CrateSource {
     pub rlib: Option<PathBuf>,
     pub rmeta: Option<PathBuf>,
     pub sdylib_interface: Option<PathBuf>,
-    /// Path to `.spans` file for crates compiled with `-Z separate-spans`.
+    /// Path to `.spans` file for crates compiled with `-Z stable-crate-hash`.
     pub spans: Option<PathBuf>,
 }
 

compiler/rustc_session/src/options.rs

@@ -2658,8 +2658,8 @@ written to standard error output)"),
         for example: `-Z self-profile-events=default,query-keys`
         all options: none, all, default, generic-activity, query-provider, query-cache-hit
                      query-blocked, incr-cache-load, incr-result-hashing, query-keys, function-args, args, llvm, artifact-sizes"),
-    separate_spans: bool = (false, parse_bool, [TRACKED],
-        "store span data in a separate .spans file for Relink, Don't Rebuild (RDR) (default: no)"),
+    stable_crate_hash: bool = (false, parse_bool, [TRACKED],
+        "stabilize the crate hash by storing spans separately, enabling relink-don't-rebuild (default: no)"),
     share_generics: Option<bool> = (None, parse_opt_bool, [TRACKED],
         "make the current crate share its generic instantiations"),
     shell_argfiles: bool = (false, parse_bool, [UNTRACKED],

compiler/rustc_session/src/session.rs

@@ -286,7 +286,7 @@ impl Session {
     }
 
     pub fn diagnostic_spans_hash(&self) -> Option<u64> {
-        if !self.opts.unstable_opts.separate_spans {
+        if !self.opts.unstable_opts.stable_crate_hash {
             return None;
         }