Start of marking remapping with an enum

This commit is rather large, as simply moving from boolean to enum
marking results in many places in the crate changing.

This commit does not compile as the `Name` would have to be `pub`, which
may result in even more changes required and is not part of the
originally proposed cleanup.

Author: Nicholas-Baron

src/librustc_span/lib.rs

@@ -1074,15 +1074,94 @@ impl SourceFileHash {
     }
 }
 
-/// A single source in the `SourceMap`.
-#[derive(Clone)]
-pub struct SourceFile {
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum Name {
     /// The name of the file that the source came from. Source that doesn't
     /// originate from files has names between angle brackets by convention
     /// (e.g., `<anon>`).
-    pub name: FileName,
-    /// `true` if the `name` field above has been modified by `--remap-path-prefix`.
-    pub name_was_remapped: bool,
+    Normal(FileName),
+    /// FileName modified by `--remap-path-prefix`.
+    Remapped(FileName),
+}
+
+impl Name {
+    pub fn new(filename: FileName, was_remapped: bool) -> Self {
+        if was_remapped { Name::Remapped(filename) } else { Name::Normal(filename) }
+    }
+
+    fn is_real(&self) -> bool {
+        use Name::*;
+        match *self {
+            Normal(ref name) => name.is_real(),
+            Remapped(ref name) => name.is_real(),
+        }
+    }
+
+    fn is_remapped(&self) -> bool {
+        use Name::*;
+        match *self {
+            Normal(_) => false,
+            Remapped(_) => true,
+        }
+    }
+
+    fn name_and_remapped(&self) -> (FileName, bool) {
+        use Name::*;
+        let name = match *self {
+            Normal(ref name) => name,
+            Remapped(ref name) => name,
+        };
+        (name.clone(), self.is_remapped())
+    }
+}
+
+/// Does a comparison with the filename, ignoring any remapping.
+impl PartialEq<FileName> for Name {
+    fn eq(&self, other: &FileName) -> bool {
+        use Name::*;
+        match *self {
+            Normal(ref name) => name == other,
+            Remapped(ref name) => name == other,
+        }
+    }
+}
+
+impl std::fmt::Display for Name {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use Name::*;
+        match *self {
+            Normal(ref name) => write!(fmt, "{}", name),
+            Remapped(ref name) => write!(fmt, "remapped {}", name),
+        }
+    }
+}
+
+impl Encodable for Name {
+    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+        s.emit_enum("Name", |s| match self {
+            Name::Normal(name) => s.emit_enum_variant("Normal", 0, 1, |s| name.encode(s)),
+            Name::Remapped(name) => s.emit_enum_variant("Remapped", 1, 1, |s| name.encode(s)),
+        })
+    }
+}
+
+impl Decodable for Name {
+    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
+        let names = ["Normal", "Remapped"];
+        d.read_enum("Name", |d| {
+            d.read_enum_variant(&names, |d, id| match id {
+                0 => Ok(Name::Normal(FileName::decode(d)?)),
+                1 => Ok(Name::Remapped(FileName::decode(d)?)),
+                _ => Err(d.error("Name enum variant could not be found")),
+            })
+        })
+    }
+}
+
+/// A single source in the `SourceMap`.
+#[derive(Clone)]
+pub struct SourceFile {
+    pub name: Name,
     /// The unmapped path of the file that the source came from.
     /// Set to `None` if the `SourceFile` was imported from an external crate.
     pub unmapped_path: Option<FileName>,
@@ -1115,7 +1194,6 @@ impl<S: Encoder> Encodable<S> for SourceFile {
     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_struct("SourceFile", 8, |s| {
             s.emit_struct_field("name", 0, |s| self.name.encode(s))?;
-            s.emit_struct_field("name_was_remapped", 1, |s| self.name_was_remapped.encode(s))?;
             s.emit_struct_field("src_hash", 2, |s| self.src_hash.encode(s))?;
             s.emit_struct_field("start_pos", 3, |s| self.start_pos.encode(s))?;
             s.emit_struct_field("end_pos", 4, |s| self.end_pos.encode(s))?;
@@ -1184,9 +1262,7 @@ impl<S: Encoder> Encodable<S> for SourceFile {
 impl<D: Decoder> Decodable<D> for SourceFile {
     fn decode(d: &mut D) -> Result<SourceFile, D::Error> {
         d.read_struct("SourceFile", 8, |d| {
-            let name: FileName = d.read_struct_field("name", 0, |d| Decodable::decode(d))?;
-            let name_was_remapped: bool =
-                d.read_struct_field("name_was_remapped", 1, |d| Decodable::decode(d))?;
+            let name: Name = d.read_struct_field("name", 0, |d| Decodable::decode(d))?;
             let src_hash: SourceFileHash =
                 d.read_struct_field("src_hash", 2, |d| Decodable::decode(d))?;
             let start_pos: BytePos =
@@ -1230,7 +1306,6 @@ impl<D: Decoder> Decodable<D> for SourceFile {
             let cnum: CrateNum = d.read_struct_field("cnum", 10, |d| Decodable::decode(d))?;
             Ok(SourceFile {
                 name,
-                name_was_remapped,
                 unmapped_path: None,
                 start_pos,
                 end_pos,
@@ -1281,8 +1356,7 @@ impl SourceFile {
             analyze_source_file::analyze_source_file(&src[..], start_pos);
 
         SourceFile {
-            name,
-            name_was_remapped,
+            name: if name_was_remapped { Name::Remapped(name) } else { Name::Normal(name) },
             unmapped_path: Some(unmapped_path),
             src: Some(Lrc::new(src)),
             src_hash,
@@ -1700,18 +1774,18 @@ pub enum SpanSnippetError {
     IllFormedSpan(Span),
     DistinctSources(DistinctSources),
     MalformedForSourcemap(MalformedSourceMapPositions),
-    SourceNotAvailable { filename: FileName },
+    SourceNotAvailable { filename: Name },
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct DistinctSources {
-    pub begin: (FileName, BytePos),
-    pub end: (FileName, BytePos),
+    pub begin: (Name, BytePos),
+    pub end: (Name, BytePos),
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct MalformedSourceMapPositions {
-    pub name: FileName,
+    pub name: Name,
     pub source_len: usize,
     pub begin_pos: BytePos,
     pub end_pos: BytePos,

src/librustc_span/source_map.rs

@@ -125,9 +125,10 @@ pub struct StableSourceFileId(u128);
 // StableSourceFileId, perhaps built atop source_file.name_hash.
 impl StableSourceFileId {
     pub fn new(source_file: &SourceFile) -> StableSourceFileId {
+        let (source_file_name, source_file_was_remapped) = source_file.name.name_and_remapped();
         StableSourceFileId::new_from_pieces(
-            &source_file.name,
-            source_file.name_was_remapped,
+            &source_file_name,
+            source_file_was_remapped,
             source_file.unmapped_path.as_ref(),
         )
     }
@@ -379,8 +380,7 @@ impl SourceMap {
         }
 
         let source_file = Lrc::new(SourceFile {
-            name: filename,
-            name_was_remapped,
+            name: Name::new(filename, name_was_remapped),
             unmapped_path: None,
             src: None,
             src_hash,
@@ -540,7 +540,7 @@ impl SourceMap {
     }
 
     pub fn span_to_filename(&self, sp: Span) -> FileName {
-        self.lookup_char_pos(sp.lo()).file.name.clone()
+        self.lookup_char_pos(sp.lo()).file.name.name_and_remapped().0
     }
 
     pub fn span_to_unmapped_path(&self, sp: Span) -> FileName {
@@ -906,12 +906,7 @@ impl SourceMap {
     }
 
     pub fn get_source_file(&self, filename: &FileName) -> Option<Lrc<SourceFile>> {
-        for sf in self.files.borrow().source_files.iter() {
-            if *filename == sf.name {
-                return Some(sf.clone());
-            }
-        }
-        None
+        self.files.borrow().source_files.iter().find(|sf| sf.name == *filename).cloned()
     }
 
     /// For a global `BytePos`, computes the local offset within the containing `SourceFile`.
@@ -1052,8 +1047,8 @@ impl SourceMap {
         None
     }
     pub fn ensure_source_file_source_present(&self, source_file: Lrc<SourceFile>) -> bool {
-        source_file.add_external_src(|| match source_file.name {
-            FileName::Real(ref name) => self.file_loader.read_file(name.local_path()).ok(),
+        source_file.add_external_src(|| match source_file.name.name_and_remapped() {
+            (FileName::Real(ref name), _) => self.file_loader.read_file(name.local_path()).ok(),
             _ => None,
         })
     }