diff --git a/cmd/php-parser/main.go b/cmd/php-parser/main.go
index 6bccc93..1cd927c 100644
--- a/cmd/php-parser/main.go
+++ b/cmd/php-parser/main.go
@@ -129,6 +129,7 @@ func parserWorker(fileCh <-chan *file, r chan<- result) {
 
 		parserErrors := []*errors.Error{}
 		cfg := parser.Config{
+			WithTokens: *withFreeFloating,
 			ErrorHandlerFunc: func(e *errors.Error) {
 				parserErrors = append(parserErrors, e)
 			},
@@ -154,12 +155,12 @@ func printerWorker(r <-chan result) {
 		counter++
 
 		if *printPath {
-			_, _ = io.WriteString(os.Stderr, "==> [" + strconv.Itoa(counter) + "] " + res.path + "\n")
+			_, _ = io.WriteString(os.Stderr, "==> ["+strconv.Itoa(counter)+"] "+res.path+"\n")
 		}
 
 		if *printErrors {
 			for _, e := range res.errors {
-				_, _ = io.WriteString(os.Stderr, "==> " + e.String() + "\n")
+				_, _ = io.WriteString(os.Stderr, "==> "+e.String()+"\n")
 			}
 		}
 
@@ -177,7 +178,7 @@ func printerWorker(r <-chan result) {
 			t := traverser.NewDFS(v)
 			t.Traverse(res.rootNode)
 			for _, n := range v.ResolvedNames {
-				_, _ = io.WriteString(os.Stderr, "===> " + n + "\n")
+				_, _ = io.WriteString(os.Stderr, "===> "+n+"\n")
 			}
 		}
 
diff --git a/pkg/ast/visitor/dump.go b/pkg/ast/visitor/dump.go
index 9d4c316..c86384d 100644
--- a/pkg/ast/visitor/dump.go
+++ b/pkg/ast/visitor/dump.go
@@ -3,7 +3,10 @@ package visitor
 import (
 	"fmt"
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/token"
 	"io"
+	"sort"
+	"strconv"
 	"strings"
 )
 
@@ -88,14 +91,87 @@ func (v *Dump) LeaveNode(_ ast.Vertex) {
 	v.print("\n")
 }
 
-func (v *Dump) Root(_ *ast.Root) {
-	v.printIndentIfNotSingle(v.indent - 1)
-	v.print("&ast.Root{\n")
+func (v *Dump) printNode(n *ast.Node) {
+	if n.Position == nil && n.Tokens == nil {
+		return
+	}
+
+	v.printIndent(v.indent)
+	v.print("Node: ast.Node{\n")
+
+	if n.Tokens != nil {
+		v.printIndent(v.indent + 1)
+		v.print("Tokens: token.Collection{\n")
+
+		keys := make([]int, 0, len(n.Tokens))
+		for k := range n.Tokens {
+			keys = append(keys, int(k))
+		}
+		sort.Ints(keys)
+
+		for _, k := range keys {
+			key := token.Position(k)
+
+			v.printIndent(v.indent + 2)
+			v.print("token." + key.String() + ": []token.Token{\n")
+
+			for _, tkn := range n.Tokens[key] {
+				v.printIndent(v.indent + 3)
+				v.print("{\n")
+
+				v.printIndent(v.indent + 4)
+				v.print("ID:    token." + tkn.ID.String() + ",\n")
+
+				v.printIndent(v.indent + 4)
+				v.print("Value: []byte(" + strconv.Quote(string(tkn.Value)) + "),\n")
+
+				v.printIndent(v.indent + 3)
+				v.print("},\n")
+			}
+
+			v.printIndent(v.indent + 2)
+			v.print("},\n")
+		}
+
+		v.printIndent(v.indent + 1)
+		v.print("},\n")
+	}
+
+	if n.Position != nil {
+		v.printIndent(v.indent + 1)
+		v.print("Position: &position.Position{\n")
+
+		v.printIndent(v.indent + 2)
+		v.print("StartLine: " + strconv.Itoa(n.Position.StartLine) + ",\n")
+
+		v.printIndent(v.indent + 2)
+		v.print("EndLine:   " + strconv.Itoa(n.Position.EndLine) + ",\n")
+
+		v.printIndent(v.indent + 2)
+		v.print("StartPos:  " + strconv.Itoa(n.Position.StartPos) + ",\n")
+
+		v.printIndent(v.indent + 2)
+		v.print("EndPos:    " + strconv.Itoa(n.Position.EndPos) + ",\n")
+
+		v.printIndent(v.indent + 1)
+		v.print("},\n")
+	}
+
+	v.printIndent(v.indent)
+	v.print("},\n")
 }
 
-func (v *Dump) Nullable(_ *ast.Nullable) {
+func (v *Dump) Root(n *ast.Root) {
+	v.printIndentIfNotSingle(v.indent - 1)
+	v.print("&ast.Root{\n")
+	v.printNode(n.GetNode())
+}
+
+func (v *Dump) Nullable(n *ast.Nullable) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.Nullable{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) Parameter(n *ast.Parameter) {
@@ -111,6 +187,8 @@ func (v *Dump) Parameter(n *ast.Parameter) {
 		v.printIndent(v.indent)
 		v.print("Variadic: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) Identifier(n *ast.Identifier) {
@@ -119,11 +197,15 @@ func (v *Dump) Identifier(n *ast.Identifier) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ArgumentList(_ *ast.ArgumentList) {
+func (v *Dump) ArgumentList(n *ast.ArgumentList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ArgumentList{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) Argument(n *ast.Argument) {
@@ -139,81 +221,113 @@ func (v *Dump) Argument(n *ast.Argument) {
 		v.printIndent(v.indent)
 		v.print("IsReference: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltElse(_ *ast.StmtAltElse) {
+func (v *Dump) StmtAltElse(n *ast.StmtAltElse) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltElse{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltElseIf(_ *ast.StmtAltElseIf) {
+func (v *Dump) StmtAltElseIf(n *ast.StmtAltElseIf) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltElseIf{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltFor(_ *ast.StmtAltFor) {
+func (v *Dump) StmtAltFor(n *ast.StmtAltFor) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltFor{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltForeach(_ *ast.StmtAltForeach) {
+func (v *Dump) StmtAltForeach(n *ast.StmtAltForeach) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltForeach{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltIf(_ *ast.StmtAltIf) {
+func (v *Dump) StmtAltIf(n *ast.StmtAltIf) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltIf{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltSwitch(_ *ast.StmtAltSwitch) {
+func (v *Dump) StmtAltSwitch(n *ast.StmtAltSwitch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltSwitch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtAltWhile(_ *ast.StmtAltWhile) {
+func (v *Dump) StmtAltWhile(n *ast.StmtAltWhile) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtAltWhile{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtBreak(_ *ast.StmtBreak) {
+func (v *Dump) StmtBreak(n *ast.StmtBreak) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtBreak{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtCase(_ *ast.StmtCase) {
+func (v *Dump) StmtCase(n *ast.StmtCase) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtCase{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtCaseList(_ *ast.StmtCaseList) {
+func (v *Dump) StmtCaseList(n *ast.StmtCaseList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtCaseList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtCatch(_ *ast.StmtCatch) {
+func (v *Dump) StmtCatch(n *ast.StmtCatch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtCatch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtClass(_ *ast.StmtClass) {
+func (v *Dump) StmtClass(n *ast.StmtClass) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtClass{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtClassConstList(_ *ast.StmtClassConstList) {
+func (v *Dump) StmtClassConstList(n *ast.StmtClassConstList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtClassConstList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtClassExtends(_ *ast.StmtClassExtends) {
+func (v *Dump) StmtClassExtends(n *ast.StmtClassExtends) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtClassExtends{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtClassImplements(_ *ast.StmtClassImplements) {
+func (v *Dump) StmtClassImplements(n *ast.StmtClassImplements) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtClassImplements{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) StmtClassMethod(n *ast.StmtClassMethod) {
@@ -224,21 +338,29 @@ func (v *Dump) StmtClassMethod(n *ast.StmtClassMethod) {
 		v.printIndent(v.indent)
 		v.print("ReturnsRef: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtConstList(_ *ast.StmtConstList) {
+func (v *Dump) StmtConstList(n *ast.StmtConstList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtConstList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtConstant(_ *ast.StmtConstant) {
+func (v *Dump) StmtConstant(n *ast.StmtConstant) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtConstant{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtContinue(_ *ast.StmtContinue) {
+func (v *Dump) StmtContinue(n *ast.StmtContinue) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtContinue{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) StmtDeclare(n *ast.StmtDeclare) {
@@ -249,51 +371,71 @@ func (v *Dump) StmtDeclare(n *ast.StmtDeclare) {
 		v.printIndent(v.indent)
 		v.print("Alt: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtDefault(_ *ast.StmtDefault) {
+func (v *Dump) StmtDefault(n *ast.StmtDefault) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtDefault{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtDo(_ *ast.StmtDo) {
+func (v *Dump) StmtDo(n *ast.StmtDo) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtDo{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtEcho(_ *ast.StmtEcho) {
+func (v *Dump) StmtEcho(n *ast.StmtEcho) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtEcho{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtElse(_ *ast.StmtElse) {
+func (v *Dump) StmtElse(n *ast.StmtElse) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtElse{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtElseIf(_ *ast.StmtElseIf) {
+func (v *Dump) StmtElseIf(n *ast.StmtElseIf) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtElseIf{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtExpression(_ *ast.StmtExpression) {
+func (v *Dump) StmtExpression(n *ast.StmtExpression) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtExpression{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtFinally(_ *ast.StmtFinally) {
+func (v *Dump) StmtFinally(n *ast.StmtFinally) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtFinally{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtFor(_ *ast.StmtFor) {
+func (v *Dump) StmtFor(n *ast.StmtFor) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtFor{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtForeach(_ *ast.StmtForeach) {
+func (v *Dump) StmtForeach(n *ast.StmtForeach) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtForeach{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) StmtFunction(n *ast.StmtFunction) {
@@ -304,31 +446,43 @@ func (v *Dump) StmtFunction(n *ast.StmtFunction) {
 		v.printIndent(v.indent)
 		v.print("ReturnsRef: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtGlobal(_ *ast.StmtGlobal) {
+func (v *Dump) StmtGlobal(n *ast.StmtGlobal) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtGlobal{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtGoto(_ *ast.StmtGoto) {
+func (v *Dump) StmtGoto(n *ast.StmtGoto) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtGoto{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtGroupUse(_ *ast.StmtGroupUse) {
+func (v *Dump) StmtGroupUse(n *ast.StmtGroupUse) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtGroupUse{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtHaltCompiler(_ *ast.StmtHaltCompiler) {
+func (v *Dump) StmtHaltCompiler(n *ast.StmtHaltCompiler) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtHaltCompiler{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtIf(_ *ast.StmtIf) {
+func (v *Dump) StmtIf(n *ast.StmtIf) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtIf{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) StmtInlineHtml(n *ast.StmtInlineHtml) {
@@ -337,136 +491,190 @@ func (v *Dump) StmtInlineHtml(n *ast.StmtInlineHtml) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtInterface(_ *ast.StmtInterface) {
+func (v *Dump) StmtInterface(n *ast.StmtInterface) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtInterface{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtInterfaceExtends(_ *ast.StmtInterfaceExtends) {
+func (v *Dump) StmtInterfaceExtends(n *ast.StmtInterfaceExtends) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtInterfaceExtends{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtLabel(_ *ast.StmtLabel) {
+func (v *Dump) StmtLabel(n *ast.StmtLabel) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtLabel{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtNamespace(_ *ast.StmtNamespace) {
+func (v *Dump) StmtNamespace(n *ast.StmtNamespace) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtNamespace{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtNop(_ *ast.StmtNop) {
+func (v *Dump) StmtNop(n *ast.StmtNop) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtNop{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtProperty(_ *ast.StmtProperty) {
+func (v *Dump) StmtProperty(n *ast.StmtProperty) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtProperty{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtPropertyList(_ *ast.StmtPropertyList) {
+func (v *Dump) StmtPropertyList(n *ast.StmtPropertyList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtPropertyList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtReturn(_ *ast.StmtReturn) {
+func (v *Dump) StmtReturn(n *ast.StmtReturn) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtReturn{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtStatic(_ *ast.StmtStatic) {
+func (v *Dump) StmtStatic(n *ast.StmtStatic) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtStatic{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtStaticVar(_ *ast.StmtStaticVar) {
+func (v *Dump) StmtStaticVar(n *ast.StmtStaticVar) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtStaticVar{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtStmtList(_ *ast.StmtStmtList) {
+func (v *Dump) StmtStmtList(n *ast.StmtStmtList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtStmtList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtSwitch(_ *ast.StmtSwitch) {
+func (v *Dump) StmtSwitch(n *ast.StmtSwitch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtSwitch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtThrow(_ *ast.StmtThrow) {
+func (v *Dump) StmtThrow(n *ast.StmtThrow) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtThrow{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTrait(_ *ast.StmtTrait) {
+func (v *Dump) StmtTrait(n *ast.StmtTrait) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTrait{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTraitAdaptationList(_ *ast.StmtTraitAdaptationList) {
+func (v *Dump) StmtTraitAdaptationList(n *ast.StmtTraitAdaptationList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTraitAdaptationList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTraitMethodRef(_ *ast.StmtTraitMethodRef) {
+func (v *Dump) StmtTraitMethodRef(n *ast.StmtTraitMethodRef) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTraitMethodRef{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTraitUse(_ *ast.StmtTraitUse) {
+func (v *Dump) StmtTraitUse(n *ast.StmtTraitUse) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTraitUse{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTraitUseAlias(_ *ast.StmtTraitUseAlias) {
+func (v *Dump) StmtTraitUseAlias(n *ast.StmtTraitUseAlias) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTraitUseAlias{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTraitUsePrecedence(_ *ast.StmtTraitUsePrecedence) {
+func (v *Dump) StmtTraitUsePrecedence(n *ast.StmtTraitUsePrecedence) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTraitUsePrecedence{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtTry(_ *ast.StmtTry) {
+func (v *Dump) StmtTry(n *ast.StmtTry) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtTry{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtUnset(_ *ast.StmtUnset) {
+func (v *Dump) StmtUnset(n *ast.StmtUnset) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtUnset{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtUse(_ *ast.StmtUse) {
+func (v *Dump) StmtUse(n *ast.StmtUse) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtUse{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtUseList(_ *ast.StmtUseList) {
+func (v *Dump) StmtUseList(n *ast.StmtUseList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtUseList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) StmtWhile(_ *ast.StmtWhile) {
+func (v *Dump) StmtWhile(n *ast.StmtWhile) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.StmtWhile{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprArray(_ *ast.ExprArray) {
+func (v *Dump) ExprArray(n *ast.ExprArray) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprArray{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprArrayDimFetch(_ *ast.ExprArrayDimFetch) {
+func (v *Dump) ExprArrayDimFetch(n *ast.ExprArrayDimFetch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprArrayDimFetch{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ExprArrayItem(n *ast.ExprArrayItem) {
@@ -477,6 +685,8 @@ func (v *Dump) ExprArrayItem(n *ast.ExprArrayItem) {
 		v.printIndent(v.indent)
 		v.print("Unpack: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ExprArrowFunction(n *ast.ExprArrowFunction) {
@@ -492,26 +702,36 @@ func (v *Dump) ExprArrowFunction(n *ast.ExprArrowFunction) {
 		v.printIndent(v.indent)
 		v.print("Static: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBitwiseNot(_ *ast.ExprBitwiseNot) {
+func (v *Dump) ExprBitwiseNot(n *ast.ExprBitwiseNot) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBitwiseNot{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBooleanNot(_ *ast.ExprBooleanNot) {
+func (v *Dump) ExprBooleanNot(n *ast.ExprBooleanNot) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBooleanNot{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprClassConstFetch(_ *ast.ExprClassConstFetch) {
+func (v *Dump) ExprClassConstFetch(n *ast.ExprClassConstFetch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprClassConstFetch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprClone(_ *ast.ExprClone) {
+func (v *Dump) ExprClone(n *ast.ExprClone) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprClone{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ExprClosure(n *ast.ExprClosure) {
@@ -527,31 +747,43 @@ func (v *Dump) ExprClosure(n *ast.ExprClosure) {
 		v.printIndent(v.indent)
 		v.print("Static: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprClosureUse(_ *ast.ExprClosureUse) {
+func (v *Dump) ExprClosureUse(n *ast.ExprClosureUse) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprClosureUse{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprConstFetch(_ *ast.ExprConstFetch) {
+func (v *Dump) ExprConstFetch(n *ast.ExprConstFetch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprConstFetch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprEmpty(_ *ast.ExprEmpty) {
+func (v *Dump) ExprEmpty(n *ast.ExprEmpty) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprEmpty{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprErrorSuppress(_ *ast.ExprErrorSuppress) {
+func (v *Dump) ExprErrorSuppress(n *ast.ExprErrorSuppress) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprErrorSuppress{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprEval(_ *ast.ExprEval) {
+func (v *Dump) ExprEval(n *ast.ExprEval) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprEval{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ExprExit(n *ast.ExprExit) {
@@ -562,391 +794,547 @@ func (v *Dump) ExprExit(n *ast.ExprExit) {
 		v.printIndent(v.indent)
 		v.print("Die: true,\n")
 	}
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprFunctionCall(_ *ast.ExprFunctionCall) {
+func (v *Dump) ExprFunctionCall(n *ast.ExprFunctionCall) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprFunctionCall{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprInclude(_ *ast.ExprInclude) {
+func (v *Dump) ExprInclude(n *ast.ExprInclude) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprInclude{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprIncludeOnce(_ *ast.ExprIncludeOnce) {
+func (v *Dump) ExprIncludeOnce(n *ast.ExprIncludeOnce) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprIncludeOnce{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprInstanceOf(_ *ast.ExprInstanceOf) {
+func (v *Dump) ExprInstanceOf(n *ast.ExprInstanceOf) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprInstanceOf{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprIsset(_ *ast.ExprIsset) {
+func (v *Dump) ExprIsset(n *ast.ExprIsset) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprIsset{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprList(_ *ast.ExprList) {
+func (v *Dump) ExprList(n *ast.ExprList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprMethodCall(_ *ast.ExprMethodCall) {
+func (v *Dump) ExprMethodCall(n *ast.ExprMethodCall) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprMethodCall{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprNew(_ *ast.ExprNew) {
+func (v *Dump) ExprNew(n *ast.ExprNew) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprNew{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprPostDec(_ *ast.ExprPostDec) {
+func (v *Dump) ExprPostDec(n *ast.ExprPostDec) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprPostDec{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprPostInc(_ *ast.ExprPostInc) {
+func (v *Dump) ExprPostInc(n *ast.ExprPostInc) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprPostInc{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprPreDec(_ *ast.ExprPreDec) {
+func (v *Dump) ExprPreDec(n *ast.ExprPreDec) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprPreDec{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprPreInc(_ *ast.ExprPreInc) {
+func (v *Dump) ExprPreInc(n *ast.ExprPreInc) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprPreInc{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprPrint(_ *ast.ExprPrint) {
+func (v *Dump) ExprPrint(n *ast.ExprPrint) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprPrint{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprPropertyFetch(_ *ast.ExprPropertyFetch) {
+func (v *Dump) ExprPropertyFetch(n *ast.ExprPropertyFetch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprPropertyFetch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprReference(_ *ast.ExprReference) {
+func (v *Dump) ExprReference(n *ast.ExprReference) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprReference{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprRequire(_ *ast.ExprRequire) {
+func (v *Dump) ExprRequire(n *ast.ExprRequire) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprRequire{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprRequireOnce(_ *ast.ExprRequireOnce) {
+func (v *Dump) ExprRequireOnce(n *ast.ExprRequireOnce) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprRequireOnce{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprShellExec(_ *ast.ExprShellExec) {
+func (v *Dump) ExprShellExec(n *ast.ExprShellExec) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprShellExec{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprShortArray(_ *ast.ExprShortArray) {
+func (v *Dump) ExprShortArray(n *ast.ExprShortArray) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprShortArray{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprShortList(_ *ast.ExprShortList) {
+func (v *Dump) ExprShortList(n *ast.ExprShortList) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprShortList{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprStaticCall(_ *ast.ExprStaticCall) {
+func (v *Dump) ExprStaticCall(n *ast.ExprStaticCall) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprStaticCall{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprStaticPropertyFetch(_ *ast.ExprStaticPropertyFetch) {
+func (v *Dump) ExprStaticPropertyFetch(n *ast.ExprStaticPropertyFetch) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprStaticPropertyFetch{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprTernary(_ *ast.ExprTernary) {
+func (v *Dump) ExprTernary(n *ast.ExprTernary) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprTernary{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprUnaryMinus(_ *ast.ExprUnaryMinus) {
+func (v *Dump) ExprUnaryMinus(n *ast.ExprUnaryMinus) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprUnaryMinus{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprUnaryPlus(_ *ast.ExprUnaryPlus) {
+func (v *Dump) ExprUnaryPlus(n *ast.ExprUnaryPlus) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprUnaryPlus{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprVariable(_ *ast.ExprVariable) {
+func (v *Dump) ExprVariable(n *ast.ExprVariable) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprVariable{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprYield(_ *ast.ExprYield) {
+func (v *Dump) ExprYield(n *ast.ExprYield) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprYield{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprYieldFrom(_ *ast.ExprYieldFrom) {
+func (v *Dump) ExprYieldFrom(n *ast.ExprYieldFrom) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprYieldFrom{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssign(_ *ast.ExprAssign) {
+func (v *Dump) ExprAssign(n *ast.ExprAssign) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssign{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignReference(_ *ast.ExprAssignReference) {
+func (v *Dump) ExprAssignReference(n *ast.ExprAssignReference) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignReference{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignBitwiseAnd(_ *ast.ExprAssignBitwiseAnd) {
+func (v *Dump) ExprAssignBitwiseAnd(n *ast.ExprAssignBitwiseAnd) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignBitwiseAnd{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignBitwiseOr(_ *ast.ExprAssignBitwiseOr) {
+func (v *Dump) ExprAssignBitwiseOr(n *ast.ExprAssignBitwiseOr) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignBitwiseOr{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignBitwiseXor(_ *ast.ExprAssignBitwiseXor) {
+func (v *Dump) ExprAssignBitwiseXor(n *ast.ExprAssignBitwiseXor) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignBitwiseXor{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignCoalesce(_ *ast.ExprAssignCoalesce) {
+func (v *Dump) ExprAssignCoalesce(n *ast.ExprAssignCoalesce) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignCoalesce{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignConcat(_ *ast.ExprAssignConcat) {
+func (v *Dump) ExprAssignConcat(n *ast.ExprAssignConcat) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignConcat{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignDiv(_ *ast.ExprAssignDiv) {
+func (v *Dump) ExprAssignDiv(n *ast.ExprAssignDiv) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignDiv{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignMinus(_ *ast.ExprAssignMinus) {
+func (v *Dump) ExprAssignMinus(n *ast.ExprAssignMinus) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignMinus{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignMod(_ *ast.ExprAssignMod) {
+func (v *Dump) ExprAssignMod(n *ast.ExprAssignMod) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignMod{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignMul(_ *ast.ExprAssignMul) {
+func (v *Dump) ExprAssignMul(n *ast.ExprAssignMul) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignMul{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignPlus(_ *ast.ExprAssignPlus) {
+func (v *Dump) ExprAssignPlus(n *ast.ExprAssignPlus) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignPlus{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignPow(_ *ast.ExprAssignPow) {
+func (v *Dump) ExprAssignPow(n *ast.ExprAssignPow) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignPow{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignShiftLeft(_ *ast.ExprAssignShiftLeft) {
+func (v *Dump) ExprAssignShiftLeft(n *ast.ExprAssignShiftLeft) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignShiftLeft{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprAssignShiftRight(_ *ast.ExprAssignShiftRight) {
+func (v *Dump) ExprAssignShiftRight(n *ast.ExprAssignShiftRight) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprAssignShiftRight{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryBitwiseAnd(_ *ast.ExprBinaryBitwiseAnd) {
+func (v *Dump) ExprBinaryBitwiseAnd(n *ast.ExprBinaryBitwiseAnd) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryBitwiseAnd{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryBitwiseOr(_ *ast.ExprBinaryBitwiseOr) {
+func (v *Dump) ExprBinaryBitwiseOr(n *ast.ExprBinaryBitwiseOr) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryBitwiseOr{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryBitwiseXor(_ *ast.ExprBinaryBitwiseXor) {
+func (v *Dump) ExprBinaryBitwiseXor(n *ast.ExprBinaryBitwiseXor) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryBitwiseXor{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryBooleanAnd(_ *ast.ExprBinaryBooleanAnd) {
+func (v *Dump) ExprBinaryBooleanAnd(n *ast.ExprBinaryBooleanAnd) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryBooleanAnd{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryBooleanOr(_ *ast.ExprBinaryBooleanOr) {
+func (v *Dump) ExprBinaryBooleanOr(n *ast.ExprBinaryBooleanOr) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryBooleanOr{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryCoalesce(_ *ast.ExprBinaryCoalesce) {
+func (v *Dump) ExprBinaryCoalesce(n *ast.ExprBinaryCoalesce) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryCoalesce{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryConcat(_ *ast.ExprBinaryConcat) {
+func (v *Dump) ExprBinaryConcat(n *ast.ExprBinaryConcat) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryConcat{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryDiv(_ *ast.ExprBinaryDiv) {
+func (v *Dump) ExprBinaryDiv(n *ast.ExprBinaryDiv) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryDiv{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryEqual(_ *ast.ExprBinaryEqual) {
+func (v *Dump) ExprBinaryEqual(n *ast.ExprBinaryEqual) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryEqual{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryGreater(_ *ast.ExprBinaryGreater) {
+func (v *Dump) ExprBinaryGreater(n *ast.ExprBinaryGreater) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryGreater{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryGreaterOrEqual(_ *ast.ExprBinaryGreaterOrEqual) {
+func (v *Dump) ExprBinaryGreaterOrEqual(n *ast.ExprBinaryGreaterOrEqual) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryGreaterOrEqual{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryIdentical(_ *ast.ExprBinaryIdentical) {
+func (v *Dump) ExprBinaryIdentical(n *ast.ExprBinaryIdentical) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryIdentical{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryLogicalAnd(_ *ast.ExprBinaryLogicalAnd) {
+func (v *Dump) ExprBinaryLogicalAnd(n *ast.ExprBinaryLogicalAnd) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryLogicalAnd{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryLogicalOr(_ *ast.ExprBinaryLogicalOr) {
+func (v *Dump) ExprBinaryLogicalOr(n *ast.ExprBinaryLogicalOr) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryLogicalOr{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryLogicalXor(_ *ast.ExprBinaryLogicalXor) {
+func (v *Dump) ExprBinaryLogicalXor(n *ast.ExprBinaryLogicalXor) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryLogicalXor{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryMinus(_ *ast.ExprBinaryMinus) {
+func (v *Dump) ExprBinaryMinus(n *ast.ExprBinaryMinus) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryMinus{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryMod(_ *ast.ExprBinaryMod) {
+func (v *Dump) ExprBinaryMod(n *ast.ExprBinaryMod) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryMod{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryMul(_ *ast.ExprBinaryMul) {
+func (v *Dump) ExprBinaryMul(n *ast.ExprBinaryMul) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryMul{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryNotEqual(_ *ast.ExprBinaryNotEqual) {
+func (v *Dump) ExprBinaryNotEqual(n *ast.ExprBinaryNotEqual) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryNotEqual{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryNotIdentical(_ *ast.ExprBinaryNotIdentical) {
+func (v *Dump) ExprBinaryNotIdentical(n *ast.ExprBinaryNotIdentical) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryNotIdentical{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryPlus(_ *ast.ExprBinaryPlus) {
+func (v *Dump) ExprBinaryPlus(n *ast.ExprBinaryPlus) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryPlus{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryPow(_ *ast.ExprBinaryPow) {
+func (v *Dump) ExprBinaryPow(n *ast.ExprBinaryPow) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryPow{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryShiftLeft(_ *ast.ExprBinaryShiftLeft) {
+func (v *Dump) ExprBinaryShiftLeft(n *ast.ExprBinaryShiftLeft) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryShiftLeft{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinaryShiftRight(_ *ast.ExprBinaryShiftRight) {
+func (v *Dump) ExprBinaryShiftRight(n *ast.ExprBinaryShiftRight) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinaryShiftRight{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinarySmaller(_ *ast.ExprBinarySmaller) {
+func (v *Dump) ExprBinarySmaller(n *ast.ExprBinarySmaller) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinarySmaller{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinarySmallerOrEqual(_ *ast.ExprBinarySmallerOrEqual) {
+func (v *Dump) ExprBinarySmallerOrEqual(n *ast.ExprBinarySmallerOrEqual) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinarySmallerOrEqual{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprBinarySpaceship(_ *ast.ExprBinarySpaceship) {
+func (v *Dump) ExprBinarySpaceship(n *ast.ExprBinarySpaceship) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprBinarySpaceship{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastArray(_ *ast.ExprCastArray) {
+func (v *Dump) ExprCastArray(n *ast.ExprCastArray) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastArray{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastBool(_ *ast.ExprCastBool) {
+func (v *Dump) ExprCastBool(n *ast.ExprCastBool) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastBool{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastDouble(_ *ast.ExprCastDouble) {
+func (v *Dump) ExprCastDouble(n *ast.ExprCastDouble) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastDouble{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastInt(_ *ast.ExprCastInt) {
+func (v *Dump) ExprCastInt(n *ast.ExprCastInt) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastInt{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastObject(_ *ast.ExprCastObject) {
+func (v *Dump) ExprCastObject(n *ast.ExprCastObject) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastObject{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastString(_ *ast.ExprCastString) {
+func (v *Dump) ExprCastString(n *ast.ExprCastString) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastString{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ExprCastUnset(_ *ast.ExprCastUnset) {
+func (v *Dump) ExprCastUnset(n *ast.ExprCastUnset) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ExprCastUnset{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ScalarDnumber(n *ast.ScalarDnumber) {
@@ -955,11 +1343,15 @@ func (v *Dump) ScalarDnumber(n *ast.ScalarDnumber) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) ScalarEncapsed(_ *ast.ScalarEncapsed) {
+func (v *Dump) ScalarEncapsed(n *ast.ScalarEncapsed) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.ScalarEncapsed{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ScalarEncapsedStringPart(n *ast.ScalarEncapsedStringPart) {
@@ -968,6 +1360,8 @@ func (v *Dump) ScalarEncapsedStringPart(n *ast.ScalarEncapsedStringPart) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ScalarHeredoc(n *ast.ScalarHeredoc) {
@@ -976,6 +1370,8 @@ func (v *Dump) ScalarHeredoc(n *ast.ScalarHeredoc) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Label: %q,\n", n.Label))
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ScalarLnumber(n *ast.ScalarLnumber) {
@@ -984,6 +1380,8 @@ func (v *Dump) ScalarLnumber(n *ast.ScalarLnumber) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ScalarMagicConstant(n *ast.ScalarMagicConstant) {
@@ -992,6 +1390,8 @@ func (v *Dump) ScalarMagicConstant(n *ast.ScalarMagicConstant) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) ScalarString(n *ast.ScalarString) {
@@ -1000,21 +1400,29 @@ func (v *Dump) ScalarString(n *ast.ScalarString) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) NameName(_ *ast.NameName) {
+func (v *Dump) NameName(n *ast.NameName) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.NameName{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) NameFullyQualified(_ *ast.NameFullyQualified) {
+func (v *Dump) NameFullyQualified(n *ast.NameFullyQualified) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.NameFullyQualified{\n")
+
+	v.printNode(n.GetNode())
 }
 
-func (v *Dump) NameRelative(_ *ast.NameRelative) {
+func (v *Dump) NameRelative(n *ast.NameRelative) {
 	v.printIndentIfNotSingle(v.indent - 1)
 	v.print("&ast.NameRelative{\n")
+
+	v.printNode(n.GetNode())
 }
 
 func (v *Dump) NameNamePart(n *ast.NameNamePart) {
@@ -1023,4 +1431,6 @@ func (v *Dump) NameNamePart(n *ast.NameNamePart) {
 
 	v.printIndent(v.indent)
 	v.print(fmt.Sprintf("Value: %q,\n", n.Value))
+
+	v.printNode(n.GetNode())
 }
diff --git a/pkg/ast/visitor/dump_test.go b/pkg/ast/visitor/dump_test.go
index 3d68a0d..df92014 100644
--- a/pkg/ast/visitor/dump_test.go
+++ b/pkg/ast/visitor/dump_test.go
@@ -4,11 +4,29 @@ import (
 	"github.com/z7zmey/php-parser/pkg/ast"
 	"github.com/z7zmey/php-parser/pkg/ast/traverser"
 	"github.com/z7zmey/php-parser/pkg/ast/visitor"
+	"github.com/z7zmey/php-parser/pkg/position"
+	"github.com/z7zmey/php-parser/pkg/token"
 	"os"
 )
 
 func ExampleDump() {
 	stxTree := &ast.Root{
+		Node: ast.Node{
+			Tokens: token.Collection{
+				token.Start: []token.Token{
+					{
+						ID:    token.T_WHITESPACE,
+						Value: []byte(" "),
+					},
+				},
+			},
+			Position: &position.Position{
+				StartLine: 1,
+				EndLine:   1,
+				StartPos:  0,
+				EndPos:    1,
+			},
+		},
 		Stmts: []ast.Vertex{
 			&ast.Identifier{},
 			&ast.Parameter{
@@ -25,6 +43,22 @@ func ExampleDump() {
 
 	//output:
 	//&ast.Root{
+	//	Node: ast.Node{
+	//		Tokens: token.Collection{
+	//			token.Start: []token.Token{
+	//				{
+	//					ID:    token.T_WHITESPACE,
+	//					Value: []byte(" "),
+	//				},
+	//			},
+	//		},
+	//		Position: &position.Position{
+	//			StartLine: 1,
+	//			EndLine:   1,
+	//			StartPos:  0,
+	//			EndPos:    1,
+	//		},
+	//	},
 	//	Stmts: []ast.Vertex{
 	//		&ast.Identifier{
 	//			Value: "",
diff --git a/pkg/token/token.go b/pkg/token/token.go
index 6ba52d6..c1fa07e 100644
--- a/pkg/token/token.go
+++ b/pkg/token/token.go
@@ -1,5 +1,6 @@
 package token
 
+//go:generate stringer -type=ID -output ./token_string.go
 type ID int
 
 const (
diff --git a/pkg/token/token_string.go b/pkg/token/token_string.go
new file mode 100644
index 0000000..ce34b14
--- /dev/null
+++ b/pkg/token/token_string.go
@@ -0,0 +1,161 @@
+// Code generated by "stringer -type=ID -output ./token_string.go"; DO NOT EDIT.
+
+package token
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[T_INCLUDE-57346]
+	_ = x[T_INCLUDE_ONCE-57347]
+	_ = x[T_EXIT-57348]
+	_ = x[T_IF-57349]
+	_ = x[T_LNUMBER-57350]
+	_ = x[T_DNUMBER-57351]
+	_ = x[T_STRING-57352]
+	_ = x[T_STRING_VARNAME-57353]
+	_ = x[T_VARIABLE-57354]
+	_ = x[T_NUM_STRING-57355]
+	_ = x[T_INLINE_HTML-57356]
+	_ = x[T_CHARACTER-57357]
+	_ = x[T_BAD_CHARACTER-57358]
+	_ = x[T_ENCAPSED_AND_WHITESPACE-57359]
+	_ = x[T_CONSTANT_ENCAPSED_STRING-57360]
+	_ = x[T_ECHO-57361]
+	_ = x[T_DO-57362]
+	_ = x[T_WHILE-57363]
+	_ = x[T_ENDWHILE-57364]
+	_ = x[T_FOR-57365]
+	_ = x[T_ENDFOR-57366]
+	_ = x[T_FOREACH-57367]
+	_ = x[T_ENDFOREACH-57368]
+	_ = x[T_DECLARE-57369]
+	_ = x[T_ENDDECLARE-57370]
+	_ = x[T_AS-57371]
+	_ = x[T_SWITCH-57372]
+	_ = x[T_ENDSWITCH-57373]
+	_ = x[T_CASE-57374]
+	_ = x[T_DEFAULT-57375]
+	_ = x[T_BREAK-57376]
+	_ = x[T_CONTINUE-57377]
+	_ = x[T_GOTO-57378]
+	_ = x[T_FUNCTION-57379]
+	_ = x[T_FN-57380]
+	_ = x[T_CONST-57381]
+	_ = x[T_RETURN-57382]
+	_ = x[T_TRY-57383]
+	_ = x[T_CATCH-57384]
+	_ = x[T_FINALLY-57385]
+	_ = x[T_THROW-57386]
+	_ = x[T_USE-57387]
+	_ = x[T_INSTEADOF-57388]
+	_ = x[T_GLOBAL-57389]
+	_ = x[T_VAR-57390]
+	_ = x[T_UNSET-57391]
+	_ = x[T_ISSET-57392]
+	_ = x[T_EMPTY-57393]
+	_ = x[T_HALT_COMPILER-57394]
+	_ = x[T_CLASS-57395]
+	_ = x[T_TRAIT-57396]
+	_ = x[T_INTERFACE-57397]
+	_ = x[T_EXTENDS-57398]
+	_ = x[T_IMPLEMENTS-57399]
+	_ = x[T_OBJECT_OPERATOR-57400]
+	_ = x[T_DOUBLE_ARROW-57401]
+	_ = x[T_LIST-57402]
+	_ = x[T_ARRAY-57403]
+	_ = x[T_CALLABLE-57404]
+	_ = x[T_CLASS_C-57405]
+	_ = x[T_TRAIT_C-57406]
+	_ = x[T_METHOD_C-57407]
+	_ = x[T_FUNC_C-57408]
+	_ = x[T_LINE-57409]
+	_ = x[T_FILE-57410]
+	_ = x[T_COMMENT-57411]
+	_ = x[T_DOC_COMMENT-57412]
+	_ = x[T_OPEN_TAG-57413]
+	_ = x[T_OPEN_TAG_WITH_ECHO-57414]
+	_ = x[T_CLOSE_TAG-57415]
+	_ = x[T_WHITESPACE-57416]
+	_ = x[T_START_HEREDOC-57417]
+	_ = x[T_END_HEREDOC-57418]
+	_ = x[T_DOLLAR_OPEN_CURLY_BRACES-57419]
+	_ = x[T_CURLY_OPEN-57420]
+	_ = x[T_PAAMAYIM_NEKUDOTAYIM-57421]
+	_ = x[T_NAMESPACE-57422]
+	_ = x[T_NS_C-57423]
+	_ = x[T_DIR-57424]
+	_ = x[T_NS_SEPARATOR-57425]
+	_ = x[T_ELLIPSIS-57426]
+	_ = x[T_EVAL-57427]
+	_ = x[T_REQUIRE-57428]
+	_ = x[T_REQUIRE_ONCE-57429]
+	_ = x[T_LOGICAL_OR-57430]
+	_ = x[T_LOGICAL_XOR-57431]
+	_ = x[T_LOGICAL_AND-57432]
+	_ = x[T_INSTANCEOF-57433]
+	_ = x[T_NEW-57434]
+	_ = x[T_CLONE-57435]
+	_ = x[T_ELSEIF-57436]
+	_ = x[T_ELSE-57437]
+	_ = x[T_ENDIF-57438]
+	_ = x[T_PRINT-57439]
+	_ = x[T_YIELD-57440]
+	_ = x[T_STATIC-57441]
+	_ = x[T_ABSTRACT-57442]
+	_ = x[T_FINAL-57443]
+	_ = x[T_PRIVATE-57444]
+	_ = x[T_PROTECTED-57445]
+	_ = x[T_PUBLIC-57446]
+	_ = x[T_INC-57447]
+	_ = x[T_DEC-57448]
+	_ = x[T_YIELD_FROM-57449]
+	_ = x[T_INT_CAST-57450]
+	_ = x[T_DOUBLE_CAST-57451]
+	_ = x[T_STRING_CAST-57452]
+	_ = x[T_ARRAY_CAST-57453]
+	_ = x[T_OBJECT_CAST-57454]
+	_ = x[T_BOOL_CAST-57455]
+	_ = x[T_UNSET_CAST-57456]
+	_ = x[T_COALESCE-57457]
+	_ = x[T_SPACESHIP-57458]
+	_ = x[T_NOELSE-57459]
+	_ = x[T_PLUS_EQUAL-57460]
+	_ = x[T_MINUS_EQUAL-57461]
+	_ = x[T_MUL_EQUAL-57462]
+	_ = x[T_POW_EQUAL-57463]
+	_ = x[T_DIV_EQUAL-57464]
+	_ = x[T_CONCAT_EQUAL-57465]
+	_ = x[T_MOD_EQUAL-57466]
+	_ = x[T_AND_EQUAL-57467]
+	_ = x[T_OR_EQUAL-57468]
+	_ = x[T_XOR_EQUAL-57469]
+	_ = x[T_SL_EQUAL-57470]
+	_ = x[T_SR_EQUAL-57471]
+	_ = x[T_COALESCE_EQUAL-57472]
+	_ = x[T_BOOLEAN_OR-57473]
+	_ = x[T_BOOLEAN_AND-57474]
+	_ = x[T_POW-57475]
+	_ = x[T_SL-57476]
+	_ = x[T_SR-57477]
+	_ = x[T_IS_IDENTICAL-57478]
+	_ = x[T_IS_NOT_IDENTICAL-57479]
+	_ = x[T_IS_EQUAL-57480]
+	_ = x[T_IS_NOT_EQUAL-57481]
+	_ = x[T_IS_SMALLER_OR_EQUAL-57482]
+	_ = x[T_IS_GREATER_OR_EQUAL-57483]
+}
+
+const _ID_name = "T_INCLUDET_INCLUDE_ONCET_EXITT_IFT_LNUMBERT_DNUMBERT_STRINGT_STRING_VARNAMET_VARIABLET_NUM_STRINGT_INLINE_HTMLT_CHARACTERT_BAD_CHARACTERT_ENCAPSED_AND_WHITESPACET_CONSTANT_ENCAPSED_STRINGT_ECHOT_DOT_WHILET_ENDWHILET_FORT_ENDFORT_FOREACHT_ENDFOREACHT_DECLARET_ENDDECLARET_AST_SWITCHT_ENDSWITCHT_CASET_DEFAULTT_BREAKT_CONTINUET_GOTOT_FUNCTIONT_FNT_CONSTT_RETURNT_TRYT_CATCHT_FINALLYT_THROWT_USET_INSTEADOFT_GLOBALT_VART_UNSETT_ISSETT_EMPTYT_HALT_COMPILERT_CLASST_TRAITT_INTERFACET_EXTENDST_IMPLEMENTST_OBJECT_OPERATORT_DOUBLE_ARROWT_LISTT_ARRAYT_CALLABLET_CLASS_CT_TRAIT_CT_METHOD_CT_FUNC_CT_LINET_FILET_COMMENTT_DOC_COMMENTT_OPEN_TAGT_OPEN_TAG_WITH_ECHOT_CLOSE_TAGT_WHITESPACET_START_HEREDOCT_END_HEREDOCT_DOLLAR_OPEN_CURLY_BRACEST_CURLY_OPENT_PAAMAYIM_NEKUDOTAYIMT_NAMESPACET_NS_CT_DIRT_NS_SEPARATORT_ELLIPSIST_EVALT_REQUIRET_REQUIRE_ONCET_LOGICAL_ORT_LOGICAL_XORT_LOGICAL_ANDT_INSTANCEOFT_NEWT_CLONET_ELSEIFT_ELSET_ENDIFT_PRINTT_YIELDT_STATICT_ABSTRACTT_FINALT_PRIVATET_PROTECTEDT_PUBLICT_INCT_DECT_YIELD_FROMT_INT_CASTT_DOUBLE_CASTT_STRING_CASTT_ARRAY_CASTT_OBJECT_CASTT_BOOL_CASTT_UNSET_CASTT_COALESCET_SPACESHIPT_NOELSET_PLUS_EQUALT_MINUS_EQUALT_MUL_EQUALT_POW_EQUALT_DIV_EQUALT_CONCAT_EQUALT_MOD_EQUALT_AND_EQUALT_OR_EQUALT_XOR_EQUALT_SL_EQUALT_SR_EQUALT_COALESCE_EQUALT_BOOLEAN_ORT_BOOLEAN_ANDT_POWT_SLT_SRT_IS_IDENTICALT_IS_NOT_IDENTICALT_IS_EQUALT_IS_NOT_EQUALT_IS_SMALLER_OR_EQUALT_IS_GREATER_OR_EQUAL"
+
+var _ID_index = [...]uint16{0, 9, 23, 29, 33, 42, 51, 59, 75, 85, 97, 110, 121, 136, 161, 187, 193, 197, 204, 214, 219, 227, 236, 248, 257, 269, 273, 281, 292, 298, 307, 314, 324, 330, 340, 344, 351, 359, 364, 371, 380, 387, 392, 403, 411, 416, 423, 430, 437, 452, 459, 466, 477, 486, 498, 515, 529, 535, 542, 552, 561, 570, 580, 588, 594, 600, 609, 622, 632, 652, 663, 675, 690, 703, 729, 741, 763, 774, 780, 785, 799, 809, 815, 824, 838, 850, 863, 876, 888, 893, 900, 908, 914, 921, 928, 935, 943, 953, 960, 969, 980, 988, 993, 998, 1010, 1020, 1033, 1046, 1058, 1071, 1082, 1094, 1104, 1115, 1123, 1135, 1148, 1159, 1170, 1181, 1195, 1206, 1217, 1227, 1238, 1248, 1258, 1274, 1286, 1299, 1304, 1308, 1312, 1326, 1344, 1354, 1368, 1389, 1410}
+
+func (i ID) String() string {
+	i -= 57346
+	if i < 0 || i >= ID(len(_ID_index)-1) {
+		return "ID(" + strconv.FormatInt(int64(i+57346), 10) + ")"
+	}
+	return _ID_name[_ID_index[i]:_ID_index[i+1]]
+}