Using FileInput and VritualFileInput of FileId in inputs to support salsa upgrade

commit-id:b2dbe3c9

Author: eytan-starkware

crates/cairo-lang-defs/src/cache/mod.rs

@@ -1774,7 +1774,7 @@ impl VirtualFileCached {
             name: virtual_file.name.clone(),
             content: String::from(&*(virtual_file.content)),
             code_mappings: virtual_file.code_mappings.to_vec(),
-            kind: virtual_file.kind.clone(),
+            kind: virtual_file.kind,
             original_item_removed: virtual_file.original_item_removed,
         }
     }

crates/cairo-lang-filesystem/src/db.rs

@@ -14,7 +14,7 @@ use crate::cfg::CfgSet;
 use crate::flag::Flag;
 use crate::ids::{
     BlobId, BlobLongId, CodeMapping, CodeOrigin, CrateId, CrateLongId, Directory, FileId,
-    FileLongId, FlagId, FlagLongId, VirtualFile,
+    FileInput, FileLongId, FlagId, FlagLongId, VirtualFile,
 };
 use crate::span::{FileSummary, TextOffset, TextSpan, TextWidth};
 
@@ -203,7 +203,7 @@ pub trait FilesGroup: ExternalFiles {
     /// Change this mechanism to hold file_overrides on the db struct outside salsa mechanism,
     /// and invalidate manually.
     #[salsa::input]
-    fn file_overrides_input(&self) -> Arc<OrderedHashMap<FileLongId, Arc<str>>>;
+    fn file_overrides_input(&self) -> Arc<OrderedHashMap<FileInput, Arc<str>>>;
 
     /// Interned version of `file_overrides_input`.
     fn file_overrides(&self) -> Arc<OrderedHashMap<FileId, Arc<str>>>;
@@ -235,6 +235,9 @@ pub trait FilesGroup: ExternalFiles {
     fn blob_content(&self, blob_id: BlobId) -> Option<Arc<[u8]>>;
     /// Query to get a compilation flag by its ID.
     fn get_flag(&self, id: FlagId) -> Option<Arc<Flag>>;
+
+    /// Create an input file from an interned file id.
+    fn file_input(&self, file_id: FileId) -> FileInput;
 }
 
 pub fn init_files_group(db: &mut (dyn FilesGroup + 'static)) {
@@ -249,7 +252,9 @@ pub fn file_overrides(db: &dyn FilesGroup) -> Arc<OrderedHashMap<FileId, Arc<str
     let inp = db.file_overrides_input();
     Arc::new(
         inp.iter()
-            .map(|(file_id, content)| (file_id.clone().intern(db), content.clone()))
+            .map(|(file_id, content)| {
+                (file_id.clone().into_file_long_id(db).intern(db), content.clone())
+            })
             .collect(),
     )
 }
@@ -268,6 +273,10 @@ pub fn flags(db: &dyn FilesGroup) -> Arc<OrderedHashMap<FlagId, Arc<Flag>>> {
     Arc::new(inp.iter().map(|(flag_id, flag)| (flag_id.clone().intern(db), flag.clone())).collect())
 }
 
+fn file_input(db: &dyn FilesGroup, file_id: FileId) -> FileInput {
+    file_id.lookup_intern(db).into_file_input(db)
+}
+
 pub fn init_dev_corelib(db: &mut (dyn FilesGroup + 'static), core_lib_dir: PathBuf) {
     db.set_crate_config(
         CrateId::core(db),
@@ -294,7 +303,7 @@ pub fn init_dev_corelib(db: &mut (dyn FilesGroup + 'static), core_lib_dir: PathB
 pub trait FilesGroupEx: FilesGroup {
     /// Overrides file content. None value removes the override.
     fn override_file_content(&mut self, file: FileId, content: Option<Arc<str>>) {
-        let file = self.lookup_intern_file(file);
+        let file = self.file_input(file);
         let mut overrides = self.file_overrides_input().as_ref().clone();
         match content {
             Some(content) => overrides.insert(file, content),

crates/cairo-lang-filesystem/src/ids.rs

@@ -70,6 +70,25 @@ impl FlagId {
     }
 }
 
+/// Same as `FileLongId`, but without the interning inside virtual files.
+/// This is used to avoid the need to intern the file id inside salsa database inputs.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub enum FileInput {
+    OnDisk(PathBuf),
+    Virtual(VirtualFileInput),
+    External(salsa::InternId),
+}
+
+impl FileInput {
+    pub fn into_file_long_id(self, db: &dyn FilesGroup) -> FileLongId {
+        match self {
+            FileInput::OnDisk(path) => FileLongId::OnDisk(path),
+            FileInput::Virtual(vf) => FileLongId::Virtual(vf.into_virtual_file(db)),
+            FileInput::External(id) => FileLongId::External(id),
+        }
+    }
+}
+
 /// We use a higher level FileId struct, because not all files are on disk. Some might be online.
 /// Some might be virtual/computed on demand.
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -79,7 +98,7 @@ pub enum FileLongId {
     External(salsa::InternId),
 }
 /// Whether the file holds syntax for a module or for an expression.
-#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum FileKind {
     Module,
     Expr,
@@ -139,6 +158,31 @@ impl CodeOrigin {
     }
 }
 
+/// Same as `VirtualFile`, but without the interning inside virtual files.
+/// This is used to avoid the need to intern the file id inside salsa database inputs.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct VirtualFileInput {
+    pub parent: Option<Arc<FileInput>>,
+    pub name: SmolStr,
+    pub content: Arc<str>,
+    pub code_mappings: Arc<[CodeMapping]>,
+    pub kind: FileKind,
+    pub original_item_removed: bool,
+}
+
+impl VirtualFileInput {
+    fn into_virtual_file(self, db: &dyn FilesGroup) -> VirtualFile {
+        VirtualFile {
+            parent: self.parent.map(|id| id.as_ref().clone().into_file_long_id(db).intern(db)),
+            name: self.name,
+            content: self.content,
+            code_mappings: self.code_mappings,
+            kind: self.kind,
+            original_item_removed: self.original_item_removed,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct VirtualFile {
     pub parent: Option<FileId>,
@@ -160,36 +204,72 @@ impl VirtualFile {
             self.name.clone().into()
         }
     }
-}
 
-define_short_id!(FileId, FileLongId, FilesGroup, lookup_intern_file, intern_file);
-impl FileId {
-    pub fn new(db: &dyn FilesGroup, path: PathBuf) -> FileId {
-        FileLongId::OnDisk(path.clean()).intern(db)
+    fn into_virtual_file_input(self, db: &dyn FilesGroup) -> VirtualFileInput {
+        VirtualFileInput {
+            parent: self
+                .parent
+                .map(|id| Arc::new(id.clone().lookup_intern(db).into_file_input(db))),
+            name: self.name,
+            content: self.content,
+            code_mappings: self.code_mappings,
+            kind: self.kind,
+            original_item_removed: self.original_item_removed,
+        }
     }
-    pub fn file_name(self, db: &dyn FilesGroup) -> String {
-        match self.lookup_intern(db) {
+}
+
+impl FileLongId {
+    pub fn file_name(&self, db: &dyn FilesGroup) -> String {
+        match self {
             FileLongId::OnDisk(path) => {
                 path.file_name().and_then(|x| x.to_str()).unwrap_or("<unknown>").to_string()
             }
             FileLongId::Virtual(vf) => vf.name.to_string(),
-            FileLongId::External(external_id) => db.ext_as_virtual(external_id).name.to_string(),
+            FileLongId::External(external_id) => db.ext_as_virtual(*external_id).name.to_string(),
         }
     }
-    pub fn full_path(self, db: &dyn FilesGroup) -> String {
-        match self.lookup_intern(db) {
+    pub fn full_path(&self, db: &dyn FilesGroup) -> String {
+        match self {
             FileLongId::OnDisk(path) => path.to_str().unwrap_or("<unknown>").to_string(),
             FileLongId::Virtual(vf) => vf.full_path(db),
-            FileLongId::External(external_id) => db.ext_as_virtual(external_id).full_path(db),
+            FileLongId::External(external_id) => db.ext_as_virtual(*external_id).full_path(db),
         }
     }
-    pub fn kind(self, db: &dyn FilesGroup) -> FileKind {
-        match self.lookup_intern(db) {
+    pub fn kind(&self) -> FileKind {
+        match self {
             FileLongId::OnDisk(_) => FileKind::Module,
             FileLongId::Virtual(vf) => vf.kind,
             FileLongId::External(_) => FileKind::Module,
         }
     }
+
+    pub fn into_file_input(&self, db: &dyn FilesGroup) -> FileInput {
+        match self {
+            FileLongId::OnDisk(path) => FileInput::OnDisk(path.clone()),
+            FileLongId::Virtual(vf) => FileInput::Virtual(vf.clone().into_virtual_file_input(db)),
+            FileLongId::External(id) => FileInput::External(*id),
+        }
+    }
+}
+
+define_short_id!(FileId, FileLongId, FilesGroup, lookup_intern_file, intern_file);
+impl FileId {
+    pub fn new(db: &dyn FilesGroup, path: PathBuf) -> FileId {
+        FileLongId::OnDisk(path.clean()).intern(db)
+    }
+
+    pub fn file_name(self, db: &dyn FilesGroup) -> String {
+        self.lookup_intern(db).file_name(db)
+    }
+
+    pub fn full_path(self, db: &dyn FilesGroup) -> String {
+        self.lookup_intern(db).full_path(db)
+    }
+
+    pub fn kind(self, db: &dyn FilesGroup) -> FileKind {
+        self.lookup_intern(db).kind()
+    }
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]