creating graph for comptime folding dependencies

src/ast2/mod.rs

@@ -2302,7 +2302,7 @@ impl Ast {
                 Tag::FieldDecl => true,
                 Tag::DeclRef => self.tags[data.as_index().index()] == Tag::GlobalDecl,
                 Tag::InternedType | Tag::PointerType | Tag::ArrayType | Tag::TypeDeclRef => true,
-                Tag::CallExpr => false,
+                Tag::CallExpr => false, // are_children_comptime(self, cache),
                 Tag::FieldAccess => {
                     let parent = data.as_index_intern().0;
                     cache.mark_as_dominated_by(index, parent);
@@ -2729,6 +2729,57 @@ pub mod ast_gen {
             let mut cache = TypeCache::new();
         }
 
+        pub fn create_comptime_folding_graph(&mut self) {
+            let mut cache = ComptimeCache::default();
+            let mut nodes = self.ast.get_root_file_indices().collect::<Vec<_>>();
+            while let Some(node) = nodes.pop() {
+                if !self.ast.is_node_comptime_evaluable(&mut cache, node) {
+                    nodes.extend(self.ast.get_node_children(node));
+                }
+            }
+
+            let mut node_map = Vec::<u32>::new();
+            let edges = cache
+                .inner
+                .iter()
+                .filter(|(_, b)| **b)
+                .map(|(e, _)| self.ast.get_node_children(*e).into_iter().map(|d| (*e, d)))
+                .flatten()
+                .map(|(a, b)| (a.into_u32(), b.into_u32()))
+                .map(|(a, b)| {
+                    (
+                        node_map.iter().position(|&i| i == a).unwrap_or_else(|| {
+                            node_map.push(a);
+                            node_map.len() - 1
+                        }) as u32,
+                        node_map.iter().position(|&i| i == b).unwrap_or_else(|| {
+                            node_map.push(b);
+                            node_map.len() - 1
+                        }) as u32,
+                    )
+                })
+                .collect::<Vec<_>>();
+
+            eprintln!("cache: {cache:?}");
+            eprintln!("edges: {edges:?}");
+
+            let mut graph = petgraph::stable_graph::StableDiGraph::<(), ()>::from_edges(edges);
+            std::fs::write(
+                "comptime_graph.dot",
+                &format!("{:?}", petgraph::dot::Dot::new(&graph)),
+            )
+            .expect("writing comptime graph repr");
+
+            let a = graph
+                .externals(petgraph::Direction::Outgoing)
+                .collect::<Vec<_>>();
+            while let Some(external) = graph.externals(petgraph::Direction::Outgoing).next() {
+                _ = node_map[external.index()];
+                // comptime fold node
+                graph.remove_node(external);
+            }
+        }
+
         pub fn intern_types(&mut self) {
             let mut nodes = self
                 .ast
@@ -4294,6 +4345,7 @@ pub mod ast_gen {
             self.ast.set_root([file]);
             eprintln!("resolving decls:");
             self.resolve_decl_refs();
+            self.create_comptime_folding_graph();
             eprintln!("interning types:");
             self.intern_types();
         }