fix: assign errors once

Author: DaniPopes

crates/compilers/src/compilers/mod.rs

@@ -167,7 +167,11 @@ pub trait SourceParser: Clone + Debug + Send + Sync {
             .collect::<Result<_>>()
     }
 
-    fn finalize_imports(&mut self, _include_paths: &BTreeSet<PathBuf>) -> Result<()> {
+    fn finalize_imports(
+        &mut self,
+        _nodes: &mut Vec<Node<Self::ParsedSource>>,
+        _include_paths: &BTreeSet<PathBuf>,
+    ) -> Result<()> {
         Ok(())
     }
 }

crates/compilers/src/compilers/multi.rs

@@ -413,9 +413,40 @@ impl SourceParser for MultiCompilerParser {
             .collect())
     }
 
-    fn finalize_imports(&mut self, include_paths: &BTreeSet<PathBuf>) -> Result<()> {
-        self.solc.finalize_imports(include_paths)?;
-        self.vyper.finalize_imports(include_paths)?;
+    fn finalize_imports(
+        &mut self,
+        all_nodes: &mut Vec<crate::resolver::Node<Self::ParsedSource>>,
+        include_paths: &BTreeSet<PathBuf>,
+    ) -> Result<()> {
+        let mut solc_nodes = Vec::new();
+        let mut vyper_nodes = Vec::new();
+        for node in std::mem::take(all_nodes) {
+            match node.data {
+                MultiCompilerParsedSource::Solc(_) => {
+                    solc_nodes.push(node.map_data(|data| match data {
+                        MultiCompilerParsedSource::Solc(data) => data,
+                        _ => unreachable!(),
+                    }))
+                }
+                MultiCompilerParsedSource::Vyper(_) => {
+                    vyper_nodes.push(node.map_data(|data| match data {
+                        MultiCompilerParsedSource::Vyper(data) => data,
+                        _ => unreachable!(),
+                    }))
+                }
+            }
+        }
+
+        self.solc.finalize_imports(&mut solc_nodes, include_paths)?;
+        self.vyper.finalize_imports(&mut vyper_nodes, include_paths)?;
+
+        all_nodes.extend(
+            solc_nodes.into_iter().map(|node| node.map_data(MultiCompilerParsedSource::Solc)),
+        );
+        all_nodes.extend(
+            vyper_nodes.into_iter().map(|node| node.map_data(MultiCompilerParsedSource::Vyper)),
+        );
+
         Ok(())
     }
 }

crates/compilers/src/compilers/solc/mod.rs

@@ -399,7 +399,7 @@ impl SourceParser for SolParser {
         &mut self,
         sources: &mut Sources,
     ) -> Result<Vec<(PathBuf, Node<Self::ParsedSource>)>> {
-        self.compiler_mut().enter_mut(|compiler| {
+        self.compiler.enter_mut(|compiler| {
             let mut pcx = compiler.parse();
             pcx.set_resolve_imports(false);
             let files = sources
@@ -424,38 +424,43 @@ impl SourceParser for SolParser {
                 );
                 (path.clone(), node)
             });
-            let mut parsed = parsed.collect::<Vec<_>>();
-
-            // Set error on the first successful source, if any. This doesn't really have to be
-            // exact, as long as at least one source has an error set it should be enough.
-            if let Some(Err(diag)) = compiler.gcx().sess.emitted_errors() {
-                if let Some(idx) = parsed
-                    .iter()
-                    .position(|(_, node)| node.data.parse_result.is_ok())
-                    .or_else(|| parsed.first().map(|_| 0))
-                {
-                    let (_, node) = &mut parsed[idx];
-                    node.data.parse_result = Err(diag.to_string());
-                }
-            }
-
-            for (path, node) in &parsed {
-                if let Err(e) = &node.data.parse_result {
-                    debug!("failed parsing {}: {e}", path.display());
-                }
-            }
+            let parsed = parsed.collect::<Vec<_>>();
 
             Ok(parsed)
         })
     }
 
-    fn finalize_imports(&mut self, include_paths: &BTreeSet<PathBuf>) -> Result<()> {
-        self.compiler_mut().sess_mut().opts.include_paths.extend(include_paths.iter().cloned());
-        self.compiler_mut().enter_mut(|compiler| {
+    fn finalize_imports(
+        &mut self,
+        nodes: &mut Vec<Node<Self::ParsedSource>>,
+        include_paths: &BTreeSet<PathBuf>,
+    ) -> Result<()> {
+        let compiler = &mut self.compiler;
+        compiler.sess_mut().opts.include_paths.extend(include_paths.iter().cloned());
+        compiler.enter_mut(|compiler| {
             let mut pcx = compiler.parse();
             pcx.set_resolve_imports(true);
             pcx.force_resolve_all_imports();
         });
+
+        // Set error on the first successful source, if any. This doesn't really have to be
+        // exact, as long as at least one source has an error set it should be enough.
+        if let Some(Err(diag)) = compiler.sess().emitted_errors() {
+            if let Some(idx) = nodes
+                .iter()
+                .position(|node| node.data.parse_result.is_ok())
+                .or_else(|| nodes.first().map(|_| 0))
+            {
+                nodes[idx].data.parse_result = Err(diag.to_string());
+            }
+        }
+
+        for node in nodes.iter() {
+            if let Err(e) = &node.data.parse_result {
+                debug!("failed parsing:\n{e}");
+            }
+        }
+
         Ok(())
     }
 }

crates/compilers/src/resolver/mod.rs

@@ -484,7 +484,7 @@ impl<P: SourceParser> Graph<P> {
             );
         }
 
-        parser.finalize_imports(&resolved_solc_include_paths)?;
+        parser.finalize_imports(&mut nodes, &resolved_solc_include_paths)?;
 
         let edges = GraphEdges {
             edges,