Refine parse_sv -t option

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased](https://github.com/dalance/sv-parser/compare/v0.4.20...Unreleased) - ReleaseDate
 
+* [Changed] Refine parse_sv -t option
+* [Added] Display trait of SyntaxTree
+
 ## [v0.4.20](https://github.com/dalance/sv-parser/compare/v0.4.19...v0.4.20) - 2020-01-22
 
 * [Fixed] macro arguments spacing

sv-parser-syntaxtree/build.rs

@@ -5,20 +5,61 @@ use std::io::{BufRead, BufReader, Write};
 use std::path::Path;
 use walkdir::WalkDir;
 
+static REF_NODE_HEADER: &str = r##"
+#[derive(Clone, Debug, PartialEq, RefNode)]
+pub enum RefNode<'a> {
+    Locate(&'a Locate),
+"##;
+
+static REF_NODE_FOOTER: &str = r##"
+}
+"##;
+
+static ANY_NODE_HEADER: &str = r##"
+#[derive(Clone, Debug, PartialEq, AnyNode)]
+pub enum AnyNode {
+    Locate(Locate),
+"##;
+
+static ANY_NODE_FOOTER: &str = r##"
+}
+"##;
+
+static REF_NODE_DISPLAY_HEADER: &str = r##"
+impl<'a> std::fmt::Display for RefNode<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RefNode::Locate(_) => write!(f, "Locate"),
+"##;
+
+static REF_NODE_DISPLAY_FOOTER: &str = r##"
+        }
+    }
+}
+"##;
+
+static ANY_NODE_DISPLAY_HEADER: &str = r##"
+impl std::fmt::Display for AnyNode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            AnyNode::Locate(_) => write!(f, "Locate"),
+"##;
+
+static ANY_NODE_DISPLAY_FOOTER: &str = r##"
+        }
+    }
+}
+"##;
+
 fn main() {
     let out_dir = env::var("OUT_DIR").unwrap();
     let dest = Path::new(&out_dir).join("any_node.rs");
     let mut out = File::create(&dest).unwrap();
 
-    let mut ref_node = String::new();
+    let mut ref_node = String::from(REF_NODE_HEADER);
-    ref_node = format!("{}#[derive(Clone, Debug, PartialEq, RefNode)]\n", ref_node);
+    let mut any_node = String::from(ANY_NODE_HEADER);
-    ref_node = format!("{}pub enum RefNode<'a> {{\n", ref_node);
+    let mut ref_node_display = String::from(REF_NODE_DISPLAY_HEADER);
-    ref_node = format!("{}    Locate(&'a Locate),\n", ref_node);
+    let mut any_node_display = String::from(ANY_NODE_DISPLAY_HEADER);
-
-    let mut any_node = String::new();
-    any_node = format!("{}#[derive(Clone, Debug, PartialEq, AnyNode)]\n", any_node);
-    any_node = format!("{}pub enum AnyNode {{\n", any_node);
-    any_node = format!("{}    Locate(Locate),\n", any_node);
 
     let re_node = Regex::new(r"#\[derive.*Node.*\]").unwrap();
 
@@ -34,6 +75,14 @@ fn main() {
                     let name = line.split_whitespace().nth(2).unwrap().replace("<'a>", "");
                     ref_node = format!("{}    {}(&'a {}),\n", ref_node, name, name);
                     any_node = format!("{}    {}({}),\n", any_node, name, name);
+                    ref_node_display = format!(
+                        "{}            RefNode::{}(_) => write!(f, \"{}\"),\n",
+                        ref_node_display, name, name
+                    );
+                    any_node_display = format!(
+                        "{}            AnyNode::{}(_) => write!(f, \"{}\"),\n",
+                        any_node_display, name, name
+                    );
                     hit_node = false;
                 }
                 if re_node.is_match(&line) {
@@ -43,8 +92,12 @@ fn main() {
         }
     }
 
-    ref_node = format!("{}}}\n", ref_node);
+    ref_node = format!("{}{}\n", ref_node, REF_NODE_FOOTER);
-    any_node = format!("{}}}\n", any_node);
+    any_node = format!("{}{}\n", any_node, ANY_NODE_FOOTER);
+    ref_node_display = format!("{}{}\n", ref_node_display, REF_NODE_DISPLAY_FOOTER);
+    any_node_display = format!("{}{}\n", any_node_display, ANY_NODE_DISPLAY_FOOTER);
     let _ = write!(out, "{}", ref_node);
     let _ = write!(out, "{}", any_node);
+    let _ = write!(out, "{}", ref_node_display);
+    let _ = write!(out, "{}", any_node_display);
 }

sv-parser/src/lib.rs

@@ -52,12 +52,15 @@ impl fmt::Display for SyntaxTree {
         let mut depth = 0;
         for node in self.into_iter().event() {
             match node {
-                NodeEvent::Enter(RefNode::Locate(locate)) if !skip => {
+                NodeEvent::Enter(RefNode::Locate(locate)) => {
-                    ret.push_str(&format!(
+                    if !skip {
-                        "{}{}\n",
+                        ret.push_str(&format!(
-                        " ".repeat(depth),
+                            "{}Token: '{}' @ line:{}\n",
-                        self.get_str(locate).unwrap()
+                            " ".repeat(depth),
-                    ));
+                            self.get_str(locate).unwrap(),
+                            locate.line,
+                        ));
+                    }
                     depth += 1;
                 }
                 NodeEvent::Enter(RefNode::WhiteSpace(_)) => {
@@ -66,7 +69,10 @@ impl fmt::Display for SyntaxTree {
                 NodeEvent::Leave(RefNode::WhiteSpace(_)) => {
                     skip = false;
                 }
-                NodeEvent::Enter(_) => {
+                NodeEvent::Enter(x) => {
+                    if !skip {
+                        ret.push_str(&format!("{}{}\n", " ".repeat(depth), x));
+                    }
                     depth += 1;
                 }
                 NodeEvent::Leave(_) => {