Reintroduce assertion.

Author: cjgillot

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -522,5 +522,12 @@ fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx>, cgu: &CodegenUnit<'tcx>) -> CguR
     // know that later). If we are not doing LTO, there is only one optimized
     // version of each module, so we re-use that.
     let dep_node = cgu.codegen_dep_node(tcx);
+    tcx.dep_graph.assert_nonexistent_node(&dep_node, || {
+        format!(
+            "CompileCodegenUnit dep-node for CGU `{}` already exists before marking.",
+            cgu.name()
+        )
+    });
+
     if tcx.try_mark_green(&dep_node) { CguReuse::PostLto } else { CguReuse::No }
 }

compiler/rustc_codegen_ssa/src/base.rs

@@ -1009,6 +1009,13 @@ fn determine_cgu_reuse<'tcx>(tcx: TyCtxt<'tcx>, cgu: &CodegenUnit<'tcx>) -> CguR
     // know that later). If we are not doing LTO, there is only one optimized
     // version of each module, so we re-use that.
     let dep_node = cgu.codegen_dep_node(tcx);
+    tcx.dep_graph.assert_nonexistent_node(&dep_node, || {
+        format!(
+            "CompileCodegenUnit dep-node for CGU `{}` already exists before marking.",
+            cgu.name()
+        )
+    });
+
     if tcx.try_mark_green(&dep_node) {
         // We can re-use either the pre- or the post-thinlto state. If no LTO is
         // being performed then we can use post-LTO artifacts, otherwise we must

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -343,6 +343,14 @@ impl<K: DepKind> DepGraphData<K> {
         task: fn(Ctxt, A) -> R,
         hash_result: Option<fn(&mut StableHashingContext<'_>, &R) -> Fingerprint>,
     ) -> (R, DepNodeIndex) {
+        self.assert_nonexistent_node(&key, || {
+            format!(
+                "forcing query with already existing `DepNode`\n\
+            - query-key: {arg:?}\n\
+            - dep-node: {key:?}"
+            )
+        });
+
         let with_deps = |task_deps| K::with_deps(task_deps, || task(cx, arg));
         let (result, edges) = if cx.dep_context().is_eval_always(key.kind) {
             (with_deps(TaskDepsRef::EvalAlways), smallvec![])
@@ -633,6 +641,18 @@ impl<K: DepKind> DepGraph<K> {
 }
 
 impl<K: DepKind> DepGraphData<K> {
+    fn assert_nonexistent_node<S: std::fmt::Display>(
+        &self,
+        _dep_node: &DepNode<K>,
+        _msg: impl FnOnce() -> S,
+    ) {
+        #[cfg(debug_assertions)]
+        if let Some(seen_dep_nodes) = &self.current.seen_dep_nodes {
+            let seen = seen_dep_nodes.lock().contains(_dep_node);
+            assert!(!seen, "{}", _msg());
+        }
+    }
+
     fn node_color(&self, dep_node: &DepNode<K>) -> Option<DepNodeColor> {
         if let Some(prev_index) = self.previous.node_to_index_opt(dep_node) {
             self.colors.get(prev_index)
@@ -940,6 +960,18 @@ impl<K: DepKind> DepGraph<K> {
         self.node_color(dep_node).is_some_and(|c| c.is_green())
     }
 
+    pub fn assert_nonexistent_node<S: std::fmt::Display>(
+        &self,
+        dep_node: &DepNode<K>,
+        msg: impl FnOnce() -> S,
+    ) {
+        if cfg!(debug_assertions)
+            && let Some(data) = &self.data
+        {
+            data.assert_nonexistent_node(dep_node, msg)
+        }
+    }
+
     /// This method loads all on-disk cacheable query results into memory, so
     /// they can be written out to the new cache file again. Most query results
     /// will already be in memory but in the case where we marked something as