Merge pull request #137 from Pivot-Studio/feat/gen_flow_chart

Feat/gen flow chart

Author: Chronostasys

.gitignore

@@ -18,6 +18,8 @@ out.*
 *.asm
 *out
 *.dSYM
+*.dot
+dots
 .DS_Store
 !7zr.exe
 *.info

Cargo.lock

@@ -35,6 +35,8 @@ dunce = "1.0.3"
 toml = "0.5.9"
 ariadne = "0.1.5"
 dyn-fmt = "0.3.0"
+petgraph = "0.6.2"
+
 [dependencies.nom]
 version = "7"
 features = ["alloc"]

Cargo.toml

@@ -17,6 +17,7 @@
 - [Compiler](./compiler/README.md)
   - [Parser](./compiler/parser.md)
   - [AST](./compiler/ast.md)
+  - [Flow Chart](compiler/flow.md)
 - [Language Server](./lsp/README.md)
   - [Design](./lsp/design.md)
   - [Diagnostic](./lsp/diagnostic.md)

book/src/SUMMARY.md

@@ -0,0 +1,95 @@
+# Flow Chart
+
+这是一个附加功能，它将为每个函数生成流程图，以 `.dot` 文件格式输出，`.dot` 文件可通过
+- [Graphviz](https://graphviz.org/)  
+- [Graphviz Online](https://dreampuf.github.io/GraphvizOnline)  
+
+查看。
+
+## 依赖
+
+- [petgraph](https://github.com/petgraph/petgraph)
+
+## 实现
+
+流程图的生成包含两个步骤：  
+
+- 由 AST 生成 `图` 数据结构
+- 根据 `图` 生成 `.dot文件`
+
+### 图的生成  
+
+我们以函数为单位生成 `graph` ，而 AST 根节点为 `ProgramNode`，因此我们需要遍历其 `fntypes`
+ ，逐个生成 `graph` 最终得到一个 `Vec` ：
+
+ ```rust,no_run,noplayground
+{{#include ../../../src/flow/mod.rs:creategraphs}}
+```
+
+接下来实现 `from_ast()` 函数，它接收一个 `NodeEnum`（这是一个 `Statements` 节点）， 返回一个完整的 `Graph`，具体分为两步：
+- 初步构建图(`build_graph()`)
+- 去除不必要节点(`0入度节点`,`虚节点`,`空节点`))
+ ```rust,no_run,noplayground
+{{#include ../../../src/flow/mod.rs:fromast}}
+```
+主要介绍构建图的环节。
+
+
+
+定义图的 `节点` 与 `边` ：
+
+ ```rust,no_run,noplayground
+{{#include ../../../src/flow/mod.rs:nodeandedge}}
+```
+
+`build_graph()`函数以 `Statement` 为单位，针对不同节点构建不同的图结构，为了方便的连接节点，我们定义了 `GraphContext` 用于存储上下文信息:
+
+ ```rust,no_run,noplayground
+{{#include ../../../src/flow/mod.rs:GraphContext}}
+```
+
+每次调用 `build_graph()` 前，我们需要为构建部分提供两个 `锚点(local_source, local_sink)` ，第一次调用时，`锚点` 即为起点和终点，
+以后每次调用前，均需构建两个虚节点，作为`锚点`(虚节点之后将被去掉)。
+
+对于不涉及分支、循环、跳转的简单语句，图结构较为简单：
+
+ ```
+ local_source -> current -> local_sink
+
+ local_source ------------> local_sink // 注释
+
+ local_source ---> ERR ---> local_sink // 错误
+```
+
+分支及循环语句则较为复杂(以 `IF语句` 为例)：
+ ```
+IF:                /--Y--> sub_source -----> [...body...] ------> sub_sink ->-\
+                   /                                                            \
+local_source -> cond                                                        local_sink
+                   \                                                           /
+                    \--N--> sub_source1 -> Option<[...els...]> -> sub_sink ->-/
+
+```
+
+`if.body` 及 `if.els` 部分可以通过递归调用 `build_graph()` 构建，但是需要先生成两个虚节点，并**暂时**赋给 `ctx`，构建完毕后，
+`ctx` 的 `local_source/sink`需要还原  
+
+对于语句块，对每个语句调用 `build_graph()` ，每次将 `sub_source` 更改为 `sub_sink` ，`sub_sink` 则重新创建：
+ ```rust,no_run,noplayground
+{{#include ../../../src/flow/mod.rs:stsloop}}
+```
+
+### .dot 文件生成
+
+我们只需按dot语法格式生成图的点/边的信息即可。下面是一个简单的dot文件：
+
+```
+digraph _pointer_struct__name_params {
+    D0 [shape=box, style=rounded, label="begin", fontname=""];
+    {rank = sink; D1 [shape=box, style=rounded, label="end", fontname=""];}
+    D4 [shape=box, label="return\l", fontname=""];
+    D4 -> D1;
+    D0 -> D4;
+}
+```
+可以在[Graphviz Online](https://dreampuf.github.io/GraphvizOnline)查看对应流程图。

book/src/compiler/flow.md

@@ -32,6 +32,7 @@ use std::{
 pub struct Options {
     pub genir: bool,
     pub printast: bool,
+    pub flow: bool,
     pub optimization: HashOptimizationLevel,
     pub fmt: bool,
 }
@@ -77,6 +78,7 @@ pub enum ActionType {
     Hover,
     Compile,
     PrintAst,
+    Flow,
     Fmt,
     LspFmt,
     Hint,
@@ -192,6 +194,11 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) {
         info!("gen source done, time: {:?}", time);
         return;
     }
+    if op.flow {
+        let time = now.elapsed();
+        info!("gen flow done, time: {:?}", time);
+        return;
+    }
     let mut mods = compile_dry::accumulated::<ModBuffer>(db, docs);
     let mut objs = vec![];
     let ctx = Context::create();

src/ast/compiler.rs

@@ -29,6 +29,7 @@ use super::{
     tokens::TokenType,
 };
 
+#[derive(Clone)]
 pub struct FmtBuilder {
     buf: String,
     tabs: usize,

src/ast/fmt.rs

@@ -11,6 +11,7 @@ use crate::ast::compiler::{compile_dry_file, ActionType};
 use crate::ast::ctx::{self, Ctx};
 use crate::ast::plmod::LSPDef;
 use crate::ast::plmod::Mod;
+use crate::flow::display::Dot;
 use crate::lsp::mem_docs::{EmitParams, MemDocsInput};
 use crate::lsp::semantic_tokens::SemanticTokensBuilder;
 use crate::lsp::text;
@@ -25,6 +26,7 @@ use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 use std::cell::RefCell;
 use std::collections::hash_map::DefaultHasher;
+use std::fs;
 use std::fs::OpenOptions;
 use std::hash::{Hash, Hasher};
 use std::io::prelude::*;
@@ -240,6 +242,36 @@ impl Program {
                 let line_index = text::LineIndex::new(&oldcode);
                 PLFormat::push(db, diff.into_text_edit(&line_index));
             }
+            ActionType::Flow => {
+                if let NodeEnum::Program(pro) = *nn {
+                    // create dot dir
+                    // let mut dotpath = PathBuf::from(p.dir(db));
+                    let mut dotpath = PathBuf::from("./");
+                    dotpath.push("dots");
+                    if !dotpath.exists() {
+                        std::fs::create_dir(dotpath.clone()).unwrap();
+                    }
+                    let graphs = pro.create_graphs();
+                    for graph in graphs {
+                        let dot = Dot::new(true); // true 曲线; false 折线
+                        let dot_str = dot.generate_from_graph(&graph.graph, &graph.name);
+                        // write to file
+                        let path = format!(
+                            "{}/{}_{}.dot",
+                            dotpath.to_str().unwrap(),
+                            p.fullpath(db)
+                                .replace(|c: char| { !c.is_ascii_alphanumeric() }, "_")
+                                .replace(".pi", ""),
+                            graph.name
+                        );
+                        let mut file = fs::File::create(path.clone()).unwrap();
+                        file.write_all(dot_str.as_bytes()).unwrap();
+                        println!("{} {}", "Written to file".bright_cyan(), path.green());
+                        print!("{}", dot_str);
+                        println!("{}","You can view the flow chart on https://dreampuf.github.io/GraphvizOnline\n".bright_cyan());
+                    }
+                }
+            }
             _ => {}
         }
         let m = emit_file(db, p);

src/ast/node/program.rs

@@ -400,6 +400,7 @@ mod test {
                 optimization: crate::ast::compiler::HashOptimizationLevel::Aggressive,
                 genir: true,
                 printast: false,
+                flow: false,
                 fmt: false,
             },
         );
@@ -430,6 +431,7 @@ mod test {
                 optimization: crate::ast::compiler::HashOptimizationLevel::Aggressive,
                 genir: false,
                 printast: true,
+                flow: false,
                 fmt: false,
             },
         );

src/ast/test.rs

@@ -0,0 +1,86 @@
+use super::*;
+use petgraph::{
+    visit::IntoNodeReferences,
+    visit::{EdgeRef, IntoEdgeReferences},
+};
+
+pub struct Dot {
+    curly: bool,
+}
+
+impl Dot {
+    pub fn new(curly: bool) -> Self {
+        Dot { curly }
+    }
+    pub fn generate_from_graph(&self, graph: &Graph, name: &String) -> String {
+        let mut res = format!("digraph {} {{\n", name);
+        if !self.curly {
+            res.push_str("graph [splines=polyline];\n");
+        }
+        for (id, i) in graph.node_references() {
+            match i {
+                GraphNodeType::Begin => res.push_str(
+                    format!(
+                        "D{} [shape=box, style=rounded, label=\"begin\", fontname=\"\"];\n",
+                        id.index()
+                    )
+                    .as_str(),
+                ),
+                GraphNodeType::End => res.push_str(
+                    format!(
+                        "{{rank = sink; D{} [shape=box, style=rounded, label=\"end\", fontname=\"\"];}}\n",
+                        id.index()
+                    )
+                    .as_str(),
+                ),
+                GraphNodeType::Node(str) => res.push_str(
+                    format!(
+                        "D{} [shape=box, label=\"{}\\l\", fontname=\"\"];\n",
+                        id.index(),
+                        str.replace('\"', "\\\"").replace("\n","\\l")
+                    )
+                    .as_str(),
+                ),
+                GraphNodeType::Choice(str) => res.push_str(
+                    format!(
+                        "D{} [shape=diamond, label=\"{}?\\l\", fontname=\"\"];\n",
+                        id.index(),
+                        str.replace('\"', "\\\"").replace("\n","\\l")
+                    )
+                    .as_str(),
+                ),
+                GraphNodeType::Err(src, msg) => res.push_str(
+                    format!(
+                        "D{} [shape=box, label=<<FONT>{}</FONT><BR/><FONT COLOR=\"red\">{}</FONT>>, fontname=\"\"];\n",
+                        id.index(),
+                        src.replace('\"', "\\\"").replace("\n","\\l"),
+                        msg.replace('\"', "\\\"").replace("\n","\\l")
+                    )
+                    .as_str(),
+                ),
+                // GraphNodeType::Dummy => {} // all dummy node will be eliminated
+                GraphNodeType::Dummy => {}
+            }
+        }
+
+        for i in graph.edge_references() {
+            match i.weight() {
+                EdgeType::Normal => res.push_str(
+                    format!("D{} -> D{};\n", i.source().index(), i.target().index()).as_str(),
+                ),
+                EdgeType::Branch(t) => res.push_str(
+                    format!(
+                        "D{}:{} -> D{}:n [xlabel={}];\n",
+                        i.source().index(),
+                        if *t { "s" } else { "e" },
+                        i.target().index(),
+                        if *t { "Y" } else { "N" }
+                    )
+                    .as_str(),
+                ),
+            };
+        }
+        res.push_str("}\n");
+        res
+    }
+}