Fix ICE: attempted to remap an already remapped filename

This commit fixes an internal compiler error (ICE) that occurs when
rustdoc attempts to remap a filename that was already remapped. The
issue arose during macro expansion when the `--remap-path-prefix`
option was used.

Instead of panicking with "attempted to remap an already remapped
filename", we now handle already remapped filenames gracefully by
returning them as-is.

A test case has been added to verify this behavior.

Fixes #138520

Signed-off-by: Charalampos Mitrodimas <[email protected]>

Author: charmitro

compiler/rustc_span/src/source_map.rs

@@ -1155,19 +1155,25 @@ impl FilePathMapping {
 
     fn map_filename_prefix(&self, file: &FileName) -> (FileName, bool) {
         match file {
-            FileName::Real(realfile) if let RealFileName::LocalPath(local_path) = realfile => {
-                let (mapped_path, mapped) = self.map_prefix(local_path);
-                let realfile = if mapped {
-                    RealFileName::Remapped {
-                        local_path: Some(local_path.clone()),
-                        virtual_name: mapped_path.into_owned(),
-                    }
-                } else {
-                    realfile.clone()
-                };
-                (FileName::Real(realfile), mapped)
-            }
-            FileName::Real(_) => unreachable!("attempted to remap an already remapped filename"),
+            FileName::Real(realfile) => match realfile {
+                RealFileName::LocalPath(local_path) => {
+                    let (mapped_path, mapped) = self.map_prefix(local_path);
+                    let realfile = if mapped {
+                        RealFileName::Remapped {
+                            local_path: Some(local_path.clone()),
+                            virtual_name: mapped_path.into_owned(),
+                        }
+                    } else {
+                        realfile.clone()
+                    };
+                    (FileName::Real(realfile), mapped)
+                }
+                // If the filename is already remapped, just return it as is without attempting
+                // to remap it again. This avoids panicking when a remapped filename is passed
+                // to this function multiple times, which can happen during macro expansion
+                // in rustdoc.
+                RealFileName::Remapped { .. } => (file.clone(), false),
+            },
             other => (other.clone(), false),
         }
     }

compiler/rustc_span/src/source_map/tests.rs

@@ -489,6 +489,29 @@ fn path_prefix_remapping_reverse() {
     }
 }
 
+#[test]
+fn remapping_already_remapped_file() {
+    let mapping =
+        FilePathMapping::new(vec![(path("./"), path(""))], FileNameDisplayPreference::Remapped);
+
+    // Test remapping a local path
+    let filename = FileName::Real(RealFileName::LocalPath(path("./file.rs")));
+    let (remapped, was_mapped) = mapping.map_filename_prefix(&filename);
+    assert!(was_mapped);
+
+    // Verify we get a remapped filename
+    assert!(matches!(remapped, FileName::Real(RealFileName::Remapped { .. })));
+
+    // Now try to remap the already remapped filename - this should not panic
+    let (remapped_again, was_mapped_again) = mapping.map_filename_prefix(&remapped);
+
+    // It should return the same remapped path without attempting to remap again
+    assert!(!was_mapped_again);
+
+    // The two remapped filenames should be equal
+    assert_eq!(remapped, remapped_again);
+}
+
 #[test]
 fn test_next_point() {
     let sm = SourceMap::new(FilePathMapping::empty());