chore: change &PathBuf to &Path

Author: DaniPopes

crates/compilers/src/cache.rs

@@ -708,18 +708,16 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
 
     /// Gets or calculates the interface representation hash for the given source file.
     fn interface_repr_hash(&mut self, source: &Source, file: &Path) -> &str {
-        self.interface_repr_hashes
-            .entry(file.to_path_buf())
-            .or_insert_with(|| {
-                if let Some(r) = interface_repr_hash(&source.content, file) {
-                    return r;
-                }
-                self.content_hashes
-                    .entry(file.to_path_buf())
-                    .or_insert_with(|| source.content_hash())
-                    .clone()
-            })
-            .as_str()
+        self.interface_repr_hashes.entry(file.to_path_buf()).or_insert_with(|| {
+            if let Some(r) = interface_repr_hash(&source.content, file) {
+                return r;
+            }
+            // self.content_hash(source, file).into()
+            self.content_hashes
+                .entry(file.to_path_buf())
+                .or_insert_with(|| source.content_hash())
+                .clone()
+        })
     }
 
     /// Returns the set of [Source]s that need to be compiled to produce artifacts for requested
@@ -742,7 +740,7 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
 
             // If we are missing artifact for file, compile it.
             if self.is_missing_artifacts(file, version, profile) {
-                compile_complete.insert(file.clone());
+                compile_complete.insert(file.to_path_buf());
             }
 
             // Ensure that we have a cache entry for all sources.
@@ -756,15 +754,15 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
         for source in &compile_complete {
             for import in self.edges.imports(source) {
                 if !compile_complete.contains(import) {
-                    compile_optimized.insert(import.clone());
+                    compile_optimized.insert(import);
                 }
             }
         }
 
         sources.retain(|file, source| {
-            source.kind = if compile_complete.contains(file) {
+            source.kind = if compile_complete.contains(file.as_path()) {
                 SourceCompilationKind::Complete
-            } else if compile_optimized.contains(file) {
+            } else if compile_optimized.contains(file.as_path()) {
                 SourceCompilationKind::Optimized
             } else {
                 return false;

crates/compilers/src/filter.rs

@@ -121,7 +121,7 @@ impl<'a> SparseOutputFilter<'a> {
                 let mut required_sources = vec![file.clone()];
                 if let Some(data) = graph.get_parsed_source(file) {
                     let imports = graph.imports(file).into_iter().filter_map(|import| {
-                        graph.get_parsed_source(import).map(|data| (import.as_path(), data))
+                        graph.get_parsed_source(import).map(|data| (import, data))
                     });
                     for import in data.compilation_dependencies(imports) {
                         let import = import.to_path_buf();

crates/compilers/src/lib.rs

@@ -180,13 +180,13 @@ where
         let mut sources = Vec::new();
         let mut unique_paths = HashSet::new();
         let (path, source) = graph.node(*target_index).unpack();
-        unique_paths.insert(path.clone());
+        unique_paths.insert(path);
         sources.push((path, source));
         sources.extend(
             graph
                 .all_imported_nodes(*target_index)
                 .map(|index| graph.node(index).unpack())
-                .filter(|(p, _)| unique_paths.insert(p.to_path_buf())),
+                .filter(|(p, _)| unique_paths.insert(*p)),
         );
 
         let root = self.root();

crates/compilers/src/resolver/mod.rs

@@ -169,18 +169,18 @@ impl<D> GraphEdges<D> {
     }
 
     /// Returns all files imported by the given file
-    pub fn imports(&self, file: &Path) -> HashSet<&PathBuf> {
+    pub fn imports(&self, file: &Path) -> HashSet<&Path> {
         if let Some(start) = self.indices.get(file).copied() {
-            NodesIter::new(start, self).skip(1).map(move |idx| &self.rev_indices[&idx]).collect()
+            NodesIter::new(start, self).skip(1).map(move |idx| &*self.rev_indices[&idx]).collect()
         } else {
             HashSet::new()
         }
     }
 
     /// Returns all files that import the given file
-    pub fn importers(&self, file: &Path) -> HashSet<&PathBuf> {
+    pub fn importers(&self, file: &Path) -> HashSet<&Path> {
         if let Some(start) = self.indices.get(file).copied() {
-            self.rev_edges[start].iter().map(move |idx| &self.rev_indices[idx]).collect()
+            self.rev_edges[start].iter().map(move |idx| &*self.rev_indices[idx]).collect()
         } else {
             HashSet::new()
         }
@@ -192,7 +192,7 @@ impl<D> GraphEdges<D> {
     }
 
     /// Returns the path of the given node
-    pub fn node_path(&self, id: usize) -> &PathBuf {
+    pub fn node_path(&self, id: usize) -> &Path {
         &self.rev_indices[&id]
     }
 
@@ -327,7 +327,7 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
     }
 
     /// Returns all files imported by the given file
-    pub fn imports(&self, path: &Path) -> HashSet<&PathBuf> {
+    pub fn imports(&self, path: &Path) -> HashSet<&Path> {
         self.edges.imports(path)
     }
 
@@ -1121,7 +1121,7 @@ impl<D: ParsedSource> Node<D> {
         &self.source.content
     }
 
-    pub fn unpack(&self) -> (&PathBuf, &Source) {
+    pub fn unpack(&self) -> (&Path, &Source) {
         (&self.path, &self.source)
     }
 }
@@ -1199,8 +1199,8 @@ mod tests {
         let dapp_test = graph.node(1);
         assert_eq!(dapp_test.path, paths.sources.join("Dapp.t.sol"));
         assert_eq!(
-            dapp_test.data.imports.iter().map(|i| i.data().path()).collect::<Vec<&PathBuf>>(),
-            vec![&PathBuf::from("ds-test/test.sol"), &PathBuf::from("./Dapp.sol")]
+            dapp_test.data.imports.iter().map(|i| i.data().path()).collect::<Vec<&Path>>(),
+            vec![Path::new("ds-test/test.sol"), Path::new("./Dapp.sol")]
         );
         assert_eq!(graph.imported_nodes(1).to_vec(), vec![2, 0]);
     }

crates/compilers/src/resolver/parse.rs

@@ -187,11 +187,11 @@ impl SolImport {
         Self { path, aliases: vec![] }
     }
 
-    pub fn path(&self) -> &PathBuf {
+    pub fn path(&self) -> &Path {
         &self.path
     }
 
-    pub fn aliases(&self) -> &Vec<SolImportAlias> {
+    pub fn aliases(&self) -> &[SolImportAlias] {
         &self.aliases
     }