From 4971309b75f947cc03cfb485fd51b6949c1ddfa4 Mon Sep 17 00:00:00 2001
From: Vadym Slizov <vadym.slizov@miacar.ch>
Date: Sun, 17 May 2020 22:56:32 +0300
Subject: [PATCH] refactor printer

---
 cmd/php-parser/main.go                        |    2 +-
 internal/php5/parser.go                       |   24 +-
 internal/php5/php5.go                         |  Bin 351465 -> 352441 bytes
 internal/php5/php5.y                          |   22 +
 internal/php7/parser.go                       |   21 +-
 internal/php7/parser_test.go                  |   60 +-
 internal/php7/php7.go                         |  Bin 288574 -> 289200 bytes
 internal/php7/php7.y                          |   16 +
 internal/scanner/scanner.go                   |  Bin 384834 -> 384850 bytes
 internal/scanner/scanner.rl                   |    1 +
 internal/scanner/token.go                     |    1 +
 pkg/ast/visitor/namespace_resolver.go         |    4 +-
 pkg/ast/visitor/namespace_resolver_test.go    |   62 +-
 {printer => pkg/printer}/pretty_printer.go    | 1134 +++---
 .../printer}/pretty_printer_test.go           | 1855 +++++-----
 pkg/printer/printer.go                        | 3257 ++++++++++++++++
 .../printer}/printer_parsed_php5_test.go      |   12 +-
 .../printer}/printer_parsed_php7_test.go      |   20 +-
 {printer => pkg/printer}/printer_test.go      | 2415 ++++++------
 pkg/token/position.go                         |   13 +-
 printer/printer.go                            | 3267 -----------------
 21 files changed, 6120 insertions(+), 6066 deletions(-)
 rename {printer => pkg/printer}/pretty_printer.go (54%)
 rename {printer => pkg/printer}/pretty_printer_test.go (55%)
 create mode 100644 pkg/printer/printer.go
 rename {printer => pkg/printer}/printer_parsed_php5_test.go (99%)
 rename {printer => pkg/printer}/printer_parsed_php7_test.go (98%)
 rename {printer => pkg/printer}/printer_test.go (54%)
 delete mode 100644 printer/printer.go

diff --git a/cmd/php-parser/main.go b/cmd/php-parser/main.go
index 569dd30..33d03e0 100644
--- a/cmd/php-parser/main.go
+++ b/cmd/php-parser/main.go
@@ -13,8 +13,8 @@ import (
 
 	"github.com/pkg/profile"
 	"github.com/yookoala/realpath"
-	"github.com/z7zmey/php-parser/pkg/parser"
 	"github.com/z7zmey/php-parser/pkg/ast/visitor"
+	"github.com/z7zmey/php-parser/pkg/parser"
 )
 
 var wg sync.WaitGroup
diff --git a/internal/php5/parser.go b/internal/php5/parser.go
index 060be97..d4ec16d 100644
--- a/internal/php5/parser.go
+++ b/internal/php5/parser.go
@@ -2,6 +2,7 @@ package php5
 
 import (
 	"bytes"
+	"fmt"
 
 	"github.com/z7zmey/php-parser/internal/positionbuilder"
 	"github.com/z7zmey/php-parser/internal/scanner"
@@ -132,10 +133,25 @@ func (l *Parser) GetFreeFloatingToken(t *scanner.Token) []token.Token {
 		return []token.Token{}
 	}
 
-	tokens := make([]token.Token, len(t.Tokens))
-	copy(tokens, t.Tokens)
+	return []token.Token{
+		{
+			ID:    token.ID(t.ID),
+			Value: t.Value,
+		},
+	}
+}
 
-	return tokens
+func (l *Parser) addDollarToken(v ast.Vertex) {
+	if l.Lexer.GetWithFreeFloating() == false {
+		return
+	}
+
+	l.setFreeFloating(v, token.Dollar, []token.Token{
+		{
+			ID:    token.ID('$'),
+			Value: []byte("$"),
+		},
+	})
 }
 
 func (l *Parser) splitSemiColonAndPhpCloseTag(htmlNode ast.Vertex, prevNode ast.Vertex) {
@@ -159,6 +175,8 @@ func (l *Parser) splitSemiColonAndPhpCloseTag(htmlNode ast.Vertex, prevNode ast.
 	}
 
 	vlen := len(semiColon[0].Value)
+	fmt.Printf("vlen: %q\n", string(semiColon[0].Value))
+
 	tlen := 2
 	if bytes.HasSuffix(semiColon[0].Value, []byte("?>\n")) {
 		tlen = 3
diff --git a/internal/php5/php5.go b/internal/php5/php5.go
index 0b7071c7ed8af7138587147591722e79b8bc60c7..b63ef14d9ac832ea4a8f75c6ef740c1df8969913 100644
GIT binary patch
delta 8740
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

delta 8274
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
RcZ)EZUx-WmK3=*c{|9+$1-t+N

diff --git a/internal/php5/php5.y b/internal/php5/php5.y
index fc42063..082430d 100644
--- a/internal/php5/php5.y
+++ b/internal/php5/php5.y
@@ -1431,6 +1431,7 @@ catch_statement:
                 yylex.(*Parser).setFreeFloating(catchNode, token.Start, $1.Tokens)
                 yylex.(*Parser).setFreeFloating(catchNode, token.Catch, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $4.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(catchNode, token.Var, $5.Tokens)
                 yylex.(*Parser).setFreeFloating(catchNode, token.Cond, $6.Tokens)
                 yylex.(*Parser).setFreeFloating(catchNode, token.Stmts, $8.Tokens)
@@ -1508,6 +1509,7 @@ additional_catch:
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
                 yylex.(*Parser).setFreeFloating($$, token.Catch, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $4.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $5.Tokens)
                 yylex.(*Parser).setFreeFloating($$, token.Cond, $6.Tokens)
                 yylex.(*Parser).setFreeFloating($$, token.Stmts, $8.Tokens)
@@ -2309,6 +2311,7 @@ parameter:
                     yylex.(*Parser).setFreeFloating($$, token.Ampersand, $3.Tokens)
                 }
                 yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 // normalize
                 if $3 == nil {
@@ -2354,6 +2357,7 @@ parameter:
                 }
                 yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $5.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 // normalize
                 if $3 == nil {
@@ -2556,6 +2560,7 @@ global_var:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -2605,6 +2610,7 @@ static_var_list:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(staticVar, token.Start, $3.Tokens)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -2623,6 +2629,7 @@ static_var_list:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(staticVar, token.Start, $3.Tokens)
                 yylex.(*Parser).setFreeFloating(staticVar, token.Var, $4.Tokens)
 
@@ -2641,6 +2648,7 @@ static_var_list:
                 staticVar.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenPosition($1)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(staticVar, token.Start, $1.Tokens)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -2658,6 +2666,7 @@ static_var_list:
                 staticVar.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenNodePosition($1, $3)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(staticVar, token.Start, $1.Tokens)
                 yylex.(*Parser).setFreeFloating(staticVar, token.Var, $2.Tokens)
 
@@ -3155,6 +3164,7 @@ class_variable_declaration:
                 property.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenPosition($3)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(property, token.Start, $3.Tokens)
 
@@ -3174,6 +3184,7 @@ class_variable_declaration:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(property, token.Start, $3.Tokens)
                 yylex.(*Parser).setFreeFloating(property, token.Var, $4.Tokens)
 
@@ -3192,6 +3203,7 @@ class_variable_declaration:
                 property.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenPosition($1)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(property, token.Start, $1.Tokens)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -3209,6 +3221,7 @@ class_variable_declaration:
                 property.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenNodePosition($1, $3)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(property, token.Start, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(property, token.Var, $2.Tokens)
 
@@ -4589,6 +4602,7 @@ lexical_var_list:
                 // save comments
                 yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $3.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -4608,6 +4622,7 @@ lexical_var_list:
                 yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(reference, token.Start, $3.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $4.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -4623,6 +4638,7 @@ lexical_var_list:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -4641,6 +4657,7 @@ lexical_var_list:
                 // save comments
                 yylex.(*Parser).setFreeFloating(reference, token.Start, $1.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $2.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -6381,6 +6398,7 @@ compound_variable:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -6807,6 +6825,7 @@ encaps_var:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -6822,6 +6841,7 @@ encaps_var:
                 $$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $4)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, append($2.Tokens, yylex.(*Parser).GetFreeFloatingToken($2)...))
                 yylex.(*Parser).setFreeFloating($$, token.Expr, append($4.Tokens, yylex.(*Parser).GetFreeFloatingToken($4)...))
 
@@ -6841,6 +6861,7 @@ encaps_var:
                 $$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $3)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(fetch, token.Start, $3.Tokens)
 
@@ -6950,6 +6971,7 @@ encaps_var_offset:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
diff --git a/internal/php7/parser.go b/internal/php7/parser.go
index cb42f54..a960984 100644
--- a/internal/php7/parser.go
+++ b/internal/php7/parser.go
@@ -131,10 +131,25 @@ func (l *Parser) GetFreeFloatingToken(t *scanner.Token) []token.Token {
 		return []token.Token{}
 	}
 
-	tokens := make([]token.Token, len(t.Tokens))
-	copy(tokens, t.Tokens)
+	return []token.Token{
+		{
+			ID:    token.ID(t.ID),
+			Value: t.Value,
+		},
+	}
+}
 
-	return tokens
+func (l *Parser) addDollarToken(v ast.Vertex) {
+	if l.Lexer.GetWithFreeFloating() == false {
+		return
+	}
+
+	l.setFreeFloating(v, token.Dollar, []token.Token{
+		{
+			ID:    token.ID('$'),
+			Value: []byte("$"),
+		},
+	})
 }
 
 func (l *Parser) splitSemiColonAndPhpCloseTag(htmlNode ast.Vertex, prevNode ast.Vertex) {
diff --git a/internal/php7/parser_test.go b/internal/php7/parser_test.go
index 25490fc..bceae9c 100644
--- a/internal/php7/parser_test.go
+++ b/internal/php7/parser_test.go
@@ -982,7 +982,7 @@ func TestPhp7ParameterNode(t *testing.T) {
 						EndPos:    51,
 					},
 				},
-				ReturnsRef:    false,
+				ReturnsRef: false,
 				FunctionName: &ast.Identifier{
 					Node: ast.Node{
 						Position: &position.Position{
@@ -1183,7 +1183,7 @@ func TestPhp7ParameterNode(t *testing.T) {
 								EndPos:    117,
 							},
 						},
-						ReturnsRef:    false,
+						ReturnsRef: false,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -1397,8 +1397,8 @@ func TestPhp7ParameterNode(t *testing.T) {
 							EndPos:    162,
 						},
 					},
-					ReturnsRef:    false,
-					Static:        false,
+					ReturnsRef: false,
+					Static:     false,
 					Params: []ast.Vertex{
 						&ast.Parameter{
 							Node: ast.Node{
@@ -1577,8 +1577,8 @@ func TestPhp7ParameterNode(t *testing.T) {
 							EndPos:    214,
 						},
 					},
-					Static:        true,
-					ReturnsRef:    false,
+					Static:     true,
+					ReturnsRef: false,
 					Params: []ast.Vertex{
 						&ast.Parameter{
 							Node: ast.Node{
@@ -4376,7 +4376,7 @@ func TestStmtClassMethod_SimpleClassMethod(t *testing.T) {
 								EndPos:    31,
 							},
 						},
-						ReturnsRef:    false,
+						ReturnsRef: false,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -4454,7 +4454,7 @@ func TestStmtClassMethod_PrivateProtectedClassMethod(t *testing.T) {
 								EndPos:    45,
 							},
 						},
-						ReturnsRef:    false,
+						ReturnsRef: false,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -4511,7 +4511,7 @@ func TestStmtClassMethod_PrivateProtectedClassMethod(t *testing.T) {
 								EndPos:    73,
 							},
 						},
-						ReturnsRef:    false,
+						ReturnsRef: false,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -4602,7 +4602,7 @@ func TestStmtClassMethod_Php7ClassMethod(t *testing.T) {
 								EndPos:    52,
 							},
 						},
-						ReturnsRef:    true,
+						ReturnsRef: true,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -4740,7 +4740,7 @@ func TestStmtClassMethod_AbstractClassMethod(t *testing.T) {
 								EndPos:    54,
 							},
 						},
-						ReturnsRef:    false,
+						ReturnsRef: false,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -4854,7 +4854,7 @@ func TestStmtClassMethod_Php7AbstractClassMethod(t *testing.T) {
 								EndPos:    51,
 							},
 						},
-						ReturnsRef:    false,
+						ReturnsRef: false,
 						MethodName: &ast.Identifier{
 							Node: ast.Node{
 								Position: &position.Position{
@@ -7300,7 +7300,7 @@ func TestStmtFunction(t *testing.T) {
 						EndPos:    20,
 					},
 				},
-				ReturnsRef:    false,
+				ReturnsRef: false,
 				FunctionName: &ast.Identifier{
 					Node: ast.Node{
 						Position: &position.Position{
@@ -7345,7 +7345,7 @@ func TestStmtFunction_Return(t *testing.T) {
 						EndPos:    27,
 					},
 				},
-				ReturnsRef:    false,
+				ReturnsRef: false,
 				FunctionName: &ast.Identifier{
 					Node: ast.Node{
 						Position: &position.Position{
@@ -7401,7 +7401,7 @@ func TestStmtFunction_ReturnVar(t *testing.T) {
 						EndPos:    51,
 					},
 				},
-				ReturnsRef:    false,
+				ReturnsRef: false,
 				FunctionName: &ast.Identifier{
 					Node: ast.Node{
 						Position: &position.Position{
@@ -7568,7 +7568,7 @@ func TestStmtFunction_Ref(t *testing.T) {
 						EndPos:    30,
 					},
 				},
-				ReturnsRef:    true,
+				ReturnsRef: true,
 				FunctionName: &ast.Identifier{
 					Node: ast.Node{
 						Position: &position.Position{
@@ -7635,7 +7635,7 @@ func TestStmtFunction_ReturnType(t *testing.T) {
 						EndPos:    27,
 					},
 				},
-				ReturnsRef:    true,
+				ReturnsRef: true,
 				FunctionName: &ast.Identifier{
 					Node: ast.Node{
 						Position: &position.Position{
@@ -14535,8 +14535,8 @@ func TestExprArrowFunction(t *testing.T) {
 							EndPos:    13,
 						},
 					},
-					ReturnsRef:    false,
-					Static:        false,
+					ReturnsRef: false,
+					Static:     false,
 					Expr: &ast.ExprVariable{
 						Node: ast.Node{
 							Position: &position.Position{
@@ -14600,8 +14600,8 @@ func TestExprArrowFunction_ReturnType(t *testing.T) {
 							EndPos:    22,
 						},
 					},
-					Static:        false,
-					ReturnsRef:    true,
+					Static:     false,
+					ReturnsRef: true,
 					ReturnType: &ast.NameName{
 						Node: ast.Node{
 							Position: &position.Position{
@@ -15080,9 +15080,9 @@ func TestExprClosure(t *testing.T) {
 							EndPos:    15,
 						},
 					},
-					ReturnsRef:    false,
-					Static:        false,
-					Stmts:         []ast.Vertex{},
+					ReturnsRef: false,
+					Static:     false,
+					Stmts:      []ast.Vertex{},
 				},
 			},
 		},
@@ -15125,8 +15125,8 @@ func TestExprClosure_Use(t *testing.T) {
 							EndPos:    36,
 						},
 					},
-					ReturnsRef:    false,
-					Static:        false,
+					ReturnsRef: false,
+					Static:     false,
 					Params: []ast.Vertex{
 						&ast.Parameter{
 							Node: ast.Node{
@@ -15302,8 +15302,8 @@ func TestExprClosure_Use2(t *testing.T) {
 							EndPos:    36,
 						},
 					},
-					ReturnsRef:    false,
-					Static:        false,
+					ReturnsRef: false,
+					Static:     false,
 					Params: []ast.Vertex{
 						&ast.Parameter{
 							Node: ast.Node{
@@ -15479,8 +15479,8 @@ func TestExprClosure_ReturnType(t *testing.T) {
 							EndPos:    22,
 						},
 					},
-					ReturnsRef:    false,
-					Static:        false,
+					ReturnsRef: false,
+					Static:     false,
 					ReturnType: &ast.NameName{
 						Node: ast.Node{
 							Position: &position.Position{
diff --git a/internal/php7/php7.go b/internal/php7/php7.go
index 9a3f30acc70e4c89f744c945a1580e66496e91ed..0900ad3bc4f50b2d782f8519e24d3155b18efd06 100644
GIT binary patch
delta 6082
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

delta 5962
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

diff --git a/internal/php7/php7.y b/internal/php7/php7.y
index 9f08fa4..cd147ff 100644
--- a/internal/php7/php7.y
+++ b/internal/php7/php7.y
@@ -1368,6 +1368,7 @@ catch_list:
                 yylex.(*Parser).setFreeFloating(catch, token.Start, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(catch, token.Catch, $3.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $5.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating(catch, token.Var, $6.Tokens)
                 yylex.(*Parser).setFreeFloating(catch, token.Cond, $7.Tokens)
                 yylex.(*Parser).setFreeFloating(catch, token.Stmts, $9.Tokens)
@@ -2172,6 +2173,8 @@ parameter:
                 }
                 yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
 
+                yylex.(*Parser).addDollarToken(variable)
+
                 // normalize
                 if $3 == nil {
                     yylex.(*Parser).setFreeFloating($$, token.Ampersand, $$.GetNode().Tokens[token.Variadic]); delete($$.GetNode().Tokens, token.Variadic)
@@ -2217,6 +2220,8 @@ parameter:
                 yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $5.Tokens)
 
+                yylex.(*Parser).addDollarToken(variable)
+
                 // normalize
                 if $3 == nil {
                     yylex.(*Parser).setFreeFloating($$, token.Ampersand, $$.GetNode().Tokens[token.Variadic]); delete($$.GetNode().Tokens, token.Variadic)
@@ -2456,6 +2461,7 @@ static_var:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -2472,6 +2478,7 @@ static_var:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -2981,6 +2988,7 @@ property:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -2997,6 +3005,7 @@ property:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -4297,6 +4306,7 @@ lexical_var:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -4314,6 +4324,7 @@ lexical_var:
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
                 yylex.(*Parser).setFreeFloating(variable, token.Start, $2.Tokens)
+                yylex.(*Parser).addDollarToken(variable)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -4943,6 +4954,7 @@ simple_variable:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -5352,6 +5364,7 @@ encaps_var:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
@@ -5367,6 +5380,7 @@ encaps_var:
                 $$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $4)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, append($2.Tokens, yylex.(*Parser).GetFreeFloatingToken($2)...))
                 yylex.(*Parser).setFreeFloating($$, token.Expr, append($4.Tokens, yylex.(*Parser).GetFreeFloatingToken($4)...))
 
@@ -5386,6 +5400,7 @@ encaps_var:
                 $$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $3)
 
                 // save comments
+                yylex.(*Parser).addDollarToken(variable)
                 yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
                 yylex.(*Parser).setFreeFloating(fetch, token.Start, $3.Tokens)
 
@@ -5521,6 +5536,7 @@ encaps_var_offset:
 
                 // save comments
                 yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+                yylex.(*Parser).addDollarToken($$)
 
                 yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
             }
diff --git a/internal/scanner/scanner.go b/internal/scanner/scanner.go
index 3764cecebc814589dd6160b8a65a90d6e0ae1930..0d411e1ec8e4ad8d6a07dc73564650959747d838 100644
GIT binary patch
delta 40
ucmX@KPyEt8@rD-07N!>F7M3lnQup~eOY*Z*^YlDj6l@iM%;}Q%Sv3JRaSjIn

delta 24
gcmcb#PyEn6@rD-07N!>F7M3lnQun88-DlMR0DyT3SO5S3

diff --git a/internal/scanner/scanner.rl b/internal/scanner/scanner.rl
index 5eec481..d9195f2 100644
--- a/internal/scanner/scanner.rl
+++ b/internal/scanner/scanner.rl
@@ -510,6 +510,7 @@ func (lex *Lexer) Lex(lval Lval) int {
 
     token.Tokens = lex.Tokens
 	token.Value = lex.data[lex.ts:lex.te]
+	token.ID = tok
 
     lval.Token(token)
 
diff --git a/internal/scanner/token.go b/internal/scanner/token.go
index d45a12e..7c07126 100644
--- a/internal/scanner/token.go
+++ b/internal/scanner/token.go
@@ -6,6 +6,7 @@ import (
 
 // Token value returned by lexer
 type Token struct {
+	ID        TokenID
 	Value     []byte
 	Tokens    []token.Token
 	StartLine int
diff --git a/pkg/ast/visitor/namespace_resolver.go b/pkg/ast/visitor/namespace_resolver.go
index f79378c..3029c5c 100644
--- a/pkg/ast/visitor/namespace_resolver.go
+++ b/pkg/ast/visitor/namespace_resolver.go
@@ -27,7 +27,7 @@ func NewNamespaceResolver() *NamespaceResolver {
 
 func (nsr *NamespaceResolver) EnterNode(n ast.Vertex) bool {
 	n.Accept(nsr)
-	
+
 	if !nsr.goDeep {
 		nsr.goDeep = true
 		return false
@@ -54,7 +54,7 @@ func (nsr *NamespaceResolver) StmtUseList(n *ast.StmtUseList) {
 	for _, nn := range n.Uses {
 		nsr.AddAlias(useType, nn, nil)
 	}
-	
+
 	nsr.goDeep = false
 }
 
diff --git a/pkg/ast/visitor/namespace_resolver_test.go b/pkg/ast/visitor/namespace_resolver_test.go
index 61ed537..607aa9e 100644
--- a/pkg/ast/visitor/namespace_resolver_test.go
+++ b/pkg/ast/visitor/namespace_resolver_test.go
@@ -194,8 +194,8 @@ func TestResolveInstanceCatch(t *testing.T) {
 							nameBC,
 							nameF,
 						},
-						Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
-						Stmts:    []ast.Vertex{},
+						Var:   &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+						Stmts: []ast.Vertex{},
 					},
 				},
 			},
@@ -407,7 +407,7 @@ func TestResolveClassName(t *testing.T) {
 	nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
 
 	class := &ast.StmtClass{
-		ClassName:     &ast.Identifier{Value: []byte("A")},
+		ClassName: &ast.Identifier{Value: []byte("A")},
 		Extends: &ast.StmtClassExtends{
 			ClassName: nameAB,
 		},
@@ -472,8 +472,8 @@ func TestResolveInterfaceName(t *testing.T) {
 
 func TestResolveTraitName(t *testing.T) {
 	traitNode := &ast.StmtTrait{
-		TraitName:     &ast.Identifier{Value: []byte("A")},
-		Stmts:         []ast.Vertex{},
+		TraitName: &ast.Identifier{Value: []byte("A")},
+		Stmts:     []ast.Vertex{},
 	}
 
 	stxTree := &ast.StmtStmtList{
@@ -498,14 +498,14 @@ func TestResolveFunctionName(t *testing.T) {
 	nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
 
 	functionNode := &ast.StmtFunction{
-		ReturnsRef:    false,
-		FunctionName:  &ast.Identifier{Value: []byte("A")},
+		ReturnsRef:   false,
+		FunctionName: &ast.Identifier{Value: []byte("A")},
 		Params: []ast.Vertex{
 			&ast.Parameter{
-				ByRef:        false,
-				Variadic:     false,
-				Type: nameAB,
-				Var:     &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+				ByRef:    false,
+				Variadic: false,
+				Type:     nameAB,
+				Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
 			},
 		},
 		ReturnType: &ast.Nullable{Expr: nameBC},
@@ -536,14 +536,14 @@ func TestResolveMethodName(t *testing.T) {
 	nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
 
 	methodNode := &ast.StmtClassMethod{
-		ReturnsRef:    false,
-		MethodName:    &ast.Identifier{Value: []byte("A")},
+		ReturnsRef: false,
+		MethodName: &ast.Identifier{Value: []byte("A")},
 		Params: []ast.Vertex{
 			&ast.Parameter{
-				ByRef:        false,
-				Variadic:     false,
-				Type: nameAB,
-				Var:     &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+				ByRef:    false,
+				Variadic: false,
+				Type:     nameAB,
+				Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
 			},
 		},
 		ReturnType: &ast.Nullable{Expr: nameBC},
@@ -569,14 +569,14 @@ func TestResolveClosureName(t *testing.T) {
 	nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
 
 	closureNode := &ast.ExprClosure{
-		ReturnsRef:    false,
-		Static:        false,
+		ReturnsRef: false,
+		Static:     false,
 		Params: []ast.Vertex{
 			&ast.Parameter{
-				ByRef:        false,
-				Variadic:     false,
-				Type: nameAB,
-				Var:     &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+				ByRef:    false,
+				Variadic: false,
+				Type:     nameAB,
+				Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
 			},
 		},
 		ClosureUse: nil,
@@ -600,12 +600,12 @@ func TestResolveConstantsName(t *testing.T) {
 	nameAB := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("A")}, &ast.NameNamePart{Value: []byte("B")}}}
 
 	constantB := &ast.StmtConstant{
-		ConstantName:  &ast.Identifier{Value: []byte("B")},
-		Expr:          &ast.ScalarLnumber{Value: []byte("1")},
+		ConstantName: &ast.Identifier{Value: []byte("B")},
+		Expr:         &ast.ScalarLnumber{Value: []byte("1")},
 	}
 	constantC := &ast.StmtConstant{
-		ConstantName:  &ast.Identifier{Value: []byte("C")},
-		Expr:          &ast.ScalarLnumber{Value: []byte("1")},
+		ConstantName: &ast.Identifier{Value: []byte("C")},
+		Expr:         &ast.ScalarLnumber{Value: []byte("1")},
 	}
 
 	stxTree := &ast.StmtStmtList{
@@ -644,12 +644,12 @@ func TestResolveNamespaces(t *testing.T) {
 	relativeNameCE := &ast.NameRelative{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("C")}, &ast.NameNamePart{Value: []byte("E")}}}
 
 	constantB := &ast.StmtConstant{
-		ConstantName:  &ast.Identifier{Value: []byte("B")},
-		Expr:          &ast.ScalarLnumber{Value: []byte("1")},
+		ConstantName: &ast.Identifier{Value: []byte("B")},
+		Expr:         &ast.ScalarLnumber{Value: []byte("1")},
 	}
 	constantC := &ast.StmtConstant{
-		ConstantName:  &ast.Identifier{Value: []byte("C")},
-		Expr:          &ast.ScalarLnumber{Value: []byte("1")},
+		ConstantName: &ast.Identifier{Value: []byte("C")},
+		Expr:         &ast.ScalarLnumber{Value: []byte("1")},
 	}
 
 	stxTree := &ast.StmtStmtList{
diff --git a/printer/pretty_printer.go b/pkg/printer/pretty_printer.go
similarity index 54%
rename from printer/pretty_printer.go
rename to pkg/printer/pretty_printer.go
index 95de96f..37a1a71 100644
--- a/printer/pretty_printer.go
+++ b/pkg/printer/pretty_printer.go
@@ -4,15 +4,7 @@ import (
 	"io"
 	"strings"
 
-	"github.com/z7zmey/php-parser/node/stmt"
-
-	"github.com/z7zmey/php-parser/node"
-	"github.com/z7zmey/php-parser/node/expr"
-	"github.com/z7zmey/php-parser/node/expr/assign"
-	"github.com/z7zmey/php-parser/node/expr/binary"
-	"github.com/z7zmey/php-parser/node/expr/cast"
-	"github.com/z7zmey/php-parser/node/name"
-	"github.com/z7zmey/php-parser/node/scalar"
+	"github.com/z7zmey/php-parser/pkg/ast"
 )
 
 type PrettyPrinter struct {
@@ -30,11 +22,11 @@ func NewPrettyPrinter(w io.Writer, indentStr string) *PrettyPrinter {
 	}
 }
 
-func (p *PrettyPrinter) Print(n node.Node) {
+func (p *PrettyPrinter) Print(n ast.Vertex) {
 	p.printNode(n)
 }
 
-func (p *PrettyPrinter) joinPrint(glue string, nn []node.Node) {
+func (p *PrettyPrinter) joinPrint(glue string, nn []ast.Vertex) {
 	for k, n := range nn {
 		if k > 0 {
 			io.WriteString(p.w, glue)
@@ -44,7 +36,7 @@ func (p *PrettyPrinter) joinPrint(glue string, nn []node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printNodes(nn []node.Node) {
+func (p *PrettyPrinter) printNodes(nn []ast.Vertex) {
 	p.indentDepth++
 	l := len(nn) - 1
 	for k, n := range nn {
@@ -63,367 +55,367 @@ func (p *PrettyPrinter) printIndent() {
 	}
 }
 
-func (p *PrettyPrinter) printNode(n node.Node) {
+func (p *PrettyPrinter) printNode(n ast.Vertex) {
 	switch n.(type) {
 
 	// node
 
-	case *node.Root:
+	case *ast.Root:
 		p.printNodeRoot(n)
-	case *node.Identifier:
+	case *ast.Identifier:
 		p.printNodeIdentifier(n)
-	case *node.Parameter:
+	case *ast.Parameter:
 		p.printNodeParameter(n)
-	case *node.Nullable:
+	case *ast.Nullable:
 		p.printNodeNullable(n)
-	case *node.Argument:
+	case *ast.Argument:
 		p.printNodeArgument(n)
 
 		// name
 
-	case *name.NamePart:
+	case *ast.NameNamePart:
 		p.printNameNamePart(n)
-	case *name.Name:
+	case *ast.NameName:
 		p.printNameName(n)
-	case *name.FullyQualified:
+	case *ast.NameFullyQualified:
 		p.printNameFullyQualified(n)
-	case *name.Relative:
+	case *ast.NameRelative:
 		p.printNameRelative(n)
 
 		// scalar
 
-	case *scalar.Lnumber:
+	case *ast.ScalarLnumber:
 		p.printScalarLNumber(n)
-	case *scalar.Dnumber:
+	case *ast.ScalarDnumber:
 		p.printScalarDNumber(n)
-	case *scalar.String:
+	case *ast.ScalarString:
 		p.printScalarString(n)
-	case *scalar.EncapsedStringPart:
+	case *ast.ScalarEncapsedStringPart:
 		p.printScalarEncapsedStringPart(n)
-	case *scalar.Encapsed:
+	case *ast.ScalarEncapsed:
 		p.printScalarEncapsed(n)
-	case *scalar.Heredoc:
+	case *ast.ScalarHeredoc:
 		p.printScalarHeredoc(n)
-	case *scalar.MagicConstant:
+	case *ast.ScalarMagicConstant:
 		p.printScalarMagicConstant(n)
 
 		// assign
 
-	case *assign.Assign:
-		p.printAssign(n)
-	case *assign.Reference:
-		p.printReference(n)
-	case *assign.BitwiseAnd:
+	case *ast.ExprAssign:
+		p.printAssignAssign(n)
+	case *ast.ExprAssignReference:
+		p.printAssignReference(n)
+	case *ast.ExprAssignBitwiseAnd:
 		p.printAssignBitwiseAnd(n)
-	case *assign.BitwiseOr:
+	case *ast.ExprAssignBitwiseOr:
 		p.printAssignBitwiseOr(n)
-	case *assign.BitwiseXor:
+	case *ast.ExprAssignBitwiseXor:
 		p.printAssignBitwiseXor(n)
-	case *assign.Concat:
+	case *ast.ExprAssignConcat:
 		p.printAssignConcat(n)
-	case *assign.Div:
+	case *ast.ExprAssignDiv:
 		p.printAssignDiv(n)
-	case *assign.Minus:
+	case *ast.ExprAssignMinus:
 		p.printAssignMinus(n)
-	case *assign.Mod:
+	case *ast.ExprAssignMod:
 		p.printAssignMod(n)
-	case *assign.Mul:
+	case *ast.ExprAssignMul:
 		p.printAssignMul(n)
-	case *assign.Plus:
+	case *ast.ExprAssignPlus:
 		p.printAssignPlus(n)
-	case *assign.Pow:
+	case *ast.ExprAssignPow:
 		p.printAssignPow(n)
-	case *assign.ShiftLeft:
+	case *ast.ExprAssignShiftLeft:
 		p.printAssignShiftLeft(n)
-	case *assign.ShiftRight:
+	case *ast.ExprAssignShiftRight:
 		p.printAssignShiftRight(n)
 
 		// binary
 
-	case *binary.BitwiseAnd:
+	case *ast.ExprBinaryBitwiseAnd:
 		p.printBinaryBitwiseAnd(n)
-	case *binary.BitwiseOr:
+	case *ast.ExprBinaryBitwiseOr:
 		p.printBinaryBitwiseOr(n)
-	case *binary.BitwiseXor:
+	case *ast.ExprBinaryBitwiseXor:
 		p.printBinaryBitwiseXor(n)
-	case *binary.BooleanAnd:
+	case *ast.ExprBinaryBooleanAnd:
 		p.printBinaryBooleanAnd(n)
-	case *binary.BooleanOr:
+	case *ast.ExprBinaryBooleanOr:
 		p.printBinaryBooleanOr(n)
-	case *binary.Coalesce:
+	case *ast.ExprBinaryCoalesce:
 		p.printBinaryCoalesce(n)
-	case *binary.Concat:
+	case *ast.ExprBinaryConcat:
 		p.printBinaryConcat(n)
-	case *binary.Div:
+	case *ast.ExprBinaryDiv:
 		p.printBinaryDiv(n)
-	case *binary.Equal:
+	case *ast.ExprBinaryEqual:
 		p.printBinaryEqual(n)
-	case *binary.GreaterOrEqual:
+	case *ast.ExprBinaryGreaterOrEqual:
 		p.printBinaryGreaterOrEqual(n)
-	case *binary.Greater:
+	case *ast.ExprBinaryGreater:
 		p.printBinaryGreater(n)
-	case *binary.Identical:
+	case *ast.ExprBinaryIdentical:
 		p.printBinaryIdentical(n)
-	case *binary.LogicalAnd:
+	case *ast.ExprBinaryLogicalAnd:
 		p.printBinaryLogicalAnd(n)
-	case *binary.LogicalOr:
+	case *ast.ExprBinaryLogicalOr:
 		p.printBinaryLogicalOr(n)
-	case *binary.LogicalXor:
+	case *ast.ExprBinaryLogicalXor:
 		p.printBinaryLogicalXor(n)
-	case *binary.Minus:
+	case *ast.ExprBinaryMinus:
 		p.printBinaryMinus(n)
-	case *binary.Mod:
+	case *ast.ExprBinaryMod:
 		p.printBinaryMod(n)
-	case *binary.Mul:
+	case *ast.ExprBinaryMul:
 		p.printBinaryMul(n)
-	case *binary.NotEqual:
+	case *ast.ExprBinaryNotEqual:
 		p.printBinaryNotEqual(n)
-	case *binary.NotIdentical:
+	case *ast.ExprBinaryNotIdentical:
 		p.printBinaryNotIdentical(n)
-	case *binary.Plus:
+	case *ast.ExprBinaryPlus:
 		p.printBinaryPlus(n)
-	case *binary.Pow:
+	case *ast.ExprBinaryPow:
 		p.printBinaryPow(n)
-	case *binary.ShiftLeft:
+	case *ast.ExprBinaryShiftLeft:
 		p.printBinaryShiftLeft(n)
-	case *binary.ShiftRight:
+	case *ast.ExprBinaryShiftRight:
 		p.printBinaryShiftRight(n)
-	case *binary.SmallerOrEqual:
+	case *ast.ExprBinarySmallerOrEqual:
 		p.printBinarySmallerOrEqual(n)
-	case *binary.Smaller:
+	case *ast.ExprBinarySmaller:
 		p.printBinarySmaller(n)
-	case *binary.Spaceship:
+	case *ast.ExprBinarySpaceship:
 		p.printBinarySpaceship(n)
 
 		// cast
 
-	case *cast.Array:
+	case *ast.ExprCastArray:
 		p.printArray(n)
-	case *cast.Bool:
+	case *ast.ExprCastBool:
 		p.printBool(n)
-	case *cast.Double:
+	case *ast.ExprCastDouble:
 		p.printDouble(n)
-	case *cast.Int:
+	case *ast.ExprCastInt:
 		p.printInt(n)
-	case *cast.Object:
+	case *ast.ExprCastObject:
 		p.printObject(n)
-	case *cast.String:
+	case *ast.ExprCastString:
 		p.printString(n)
-	case *cast.Unset:
+	case *ast.ExprCastUnset:
 		p.printUnset(n)
 
 		// expr
 
-	case *expr.ArrayDimFetch:
+	case *ast.ExprArrayDimFetch:
 		p.printExprArrayDimFetch(n)
-	case *expr.ArrayItem:
+	case *ast.ExprArrayItem:
 		p.printExprArrayItem(n)
-	case *expr.Array:
+	case *ast.ExprArray:
 		p.printExprArray(n)
-	case *expr.BitwiseNot:
+	case *ast.ExprBitwiseNot:
 		p.printExprBitwiseNot(n)
-	case *expr.BooleanNot:
+	case *ast.ExprBooleanNot:
 		p.printExprBooleanNot(n)
-	case *expr.ClassConstFetch:
+	case *ast.ExprClassConstFetch:
 		p.printExprClassConstFetch(n)
-	case *expr.Clone:
+	case *ast.ExprClone:
 		p.printExprClone(n)
-	case *expr.ClosureUse:
+	case *ast.ExprClosureUse:
 		p.printExprClosureUse(n)
-	case *expr.Closure:
+	case *ast.ExprClosure:
 		p.printExprClosure(n)
-	case *expr.ConstFetch:
+	case *ast.ExprConstFetch:
 		p.printExprConstFetch(n)
-	case *expr.Empty:
+	case *ast.ExprEmpty:
 		p.printExprEmpty(n)
-	case *expr.ErrorSuppress:
+	case *ast.ExprErrorSuppress:
 		p.printExprErrorSuppress(n)
-	case *expr.Eval:
+	case *ast.ExprEval:
 		p.printExprEval(n)
-	case *expr.Exit:
+	case *ast.ExprExit:
 		p.printExprExit(n)
-	case *expr.FunctionCall:
+	case *ast.ExprFunctionCall:
 		p.printExprFunctionCall(n)
-	case *expr.Include:
+	case *ast.ExprInclude:
 		p.printExprInclude(n)
-	case *expr.IncludeOnce:
+	case *ast.ExprIncludeOnce:
 		p.printExprIncludeOnce(n)
-	case *expr.InstanceOf:
+	case *ast.ExprInstanceOf:
 		p.printExprInstanceOf(n)
-	case *expr.Isset:
+	case *ast.ExprIsset:
 		p.printExprIsset(n)
-	case *expr.List:
+	case *ast.ExprList:
 		p.printExprList(n)
-	case *expr.MethodCall:
+	case *ast.ExprMethodCall:
 		p.printExprMethodCall(n)
-	case *expr.New:
+	case *ast.ExprNew:
 		p.printExprNew(n)
-	case *expr.PostDec:
+	case *ast.ExprPostDec:
 		p.printExprPostDec(n)
-	case *expr.PostInc:
+	case *ast.ExprPostInc:
 		p.printExprPostInc(n)
-	case *expr.PreDec:
+	case *ast.ExprPreDec:
 		p.printExprPreDec(n)
-	case *expr.PreInc:
+	case *ast.ExprPreInc:
 		p.printExprPreInc(n)
-	case *expr.Print:
+	case *ast.ExprPrint:
 		p.printExprPrint(n)
-	case *expr.PropertyFetch:
+	case *ast.ExprPropertyFetch:
 		p.printExprPropertyFetch(n)
-	case *expr.Reference:
+	case *ast.ExprReference:
 		p.printExprReference(n)
-	case *expr.Require:
+	case *ast.ExprRequire:
 		p.printExprRequire(n)
-	case *expr.RequireOnce:
+	case *ast.ExprRequireOnce:
 		p.printExprRequireOnce(n)
-	case *expr.ShellExec:
+	case *ast.ExprShellExec:
 		p.printExprShellExec(n)
-	case *expr.ShortArray:
+	case *ast.ExprShortArray:
 		p.printExprShortArray(n)
-	case *expr.ShortList:
+	case *ast.ExprShortList:
 		p.printExprShortList(n)
-	case *expr.StaticCall:
+	case *ast.ExprStaticCall:
 		p.printExprStaticCall(n)
-	case *expr.StaticPropertyFetch:
+	case *ast.ExprStaticPropertyFetch:
 		p.printExprStaticPropertyFetch(n)
-	case *expr.Ternary:
+	case *ast.ExprTernary:
 		p.printExprTernary(n)
-	case *expr.UnaryMinus:
+	case *ast.ExprUnaryMinus:
 		p.printExprUnaryMinus(n)
-	case *expr.UnaryPlus:
+	case *ast.ExprUnaryPlus:
 		p.printExprUnaryPlus(n)
-	case *expr.Variable:
+	case *ast.ExprVariable:
 		p.printExprVariable(n)
-	case *expr.YieldFrom:
+	case *ast.ExprYieldFrom:
 		p.printExprYieldFrom(n)
-	case *expr.Yield:
+	case *ast.ExprYield:
 		p.printExprYield(n)
 
 		// stmt
 
-	case *stmt.AltElseIf:
+	case *ast.StmtAltElseIf:
 		p.printStmtAltElseIf(n)
-	case *stmt.AltElse:
+	case *ast.StmtAltElse:
 		p.printStmtAltElse(n)
-	case *stmt.AltFor:
+	case *ast.StmtAltFor:
 		p.printStmtAltFor(n)
-	case *stmt.AltForeach:
+	case *ast.StmtAltForeach:
 		p.printStmtAltForeach(n)
-	case *stmt.AltIf:
+	case *ast.StmtAltIf:
 		p.printStmtAltIf(n)
-	case *stmt.AltSwitch:
+	case *ast.StmtAltSwitch:
 		p.printStmtAltSwitch(n)
-	case *stmt.AltWhile:
+	case *ast.StmtAltWhile:
 		p.printStmtAltWhile(n)
-	case *stmt.Break:
+	case *ast.StmtBreak:
 		p.printStmtBreak(n)
-	case *stmt.Case:
+	case *ast.StmtCase:
 		p.printStmtCase(n)
-	case *stmt.Catch:
+	case *ast.StmtCatch:
 		p.printStmtCatch(n)
-	case *stmt.ClassMethod:
+	case *ast.StmtClassMethod:
 		p.printStmtClassMethod(n)
-	case *stmt.Class:
+	case *ast.StmtClass:
 		p.printStmtClass(n)
-	case *stmt.ClassConstList:
+	case *ast.StmtClassConstList:
 		p.printStmtClassConstList(n)
-	case *stmt.Constant:
+	case *ast.StmtConstant:
 		p.printStmtConstant(n)
-	case *stmt.Continue:
+	case *ast.StmtContinue:
 		p.printStmtContinue(n)
-	case *stmt.Declare:
+	case *ast.StmtDeclare:
 		p.printStmtDeclare(n)
-	case *stmt.Default:
+	case *ast.StmtDefault:
 		p.printStmtDefault(n)
-	case *stmt.Do:
+	case *ast.StmtDo:
 		p.printStmtDo(n)
-	case *stmt.Echo:
+	case *ast.StmtEcho:
 		p.printStmtEcho(n)
-	case *stmt.ElseIf:
+	case *ast.StmtElseIf:
 		p.printStmtElseif(n)
-	case *stmt.Else:
+	case *ast.StmtElse:
 		p.printStmtElse(n)
-	case *stmt.Expression:
+	case *ast.StmtExpression:
 		p.printStmtExpression(n)
-	case *stmt.Finally:
+	case *ast.StmtFinally:
 		p.printStmtFinally(n)
-	case *stmt.For:
+	case *ast.StmtFor:
 		p.printStmtFor(n)
-	case *stmt.Foreach:
+	case *ast.StmtForeach:
 		p.printStmtForeach(n)
-	case *stmt.Function:
+	case *ast.StmtFunction:
 		p.printStmtFunction(n)
-	case *stmt.Global:
+	case *ast.StmtGlobal:
 		p.printStmtGlobal(n)
-	case *stmt.Goto:
+	case *ast.StmtGoto:
 		p.printStmtGoto(n)
-	case *stmt.GroupUse:
+	case *ast.StmtGroupUse:
 		p.printStmtGroupUse(n)
-	case *stmt.HaltCompiler:
+	case *ast.StmtHaltCompiler:
 		p.printStmtHaltCompiler(n)
-	case *stmt.If:
+	case *ast.StmtIf:
 		p.printStmtIf(n)
-	case *stmt.InlineHtml:
+	case *ast.StmtInlineHtml:
 		p.printStmtInlineHTML(n)
-	case *stmt.Interface:
+	case *ast.StmtInterface:
 		p.printStmtInterface(n)
-	case *stmt.Label:
+	case *ast.StmtLabel:
 		p.printStmtLabel(n)
-	case *stmt.Namespace:
+	case *ast.StmtNamespace:
 		p.printStmtNamespace(n)
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.printStmtNop(n)
-	case *stmt.PropertyList:
+	case *ast.StmtPropertyList:
 		p.printStmtPropertyList(n)
-	case *stmt.Property:
+	case *ast.StmtProperty:
 		p.printStmtProperty(n)
-	case *stmt.Return:
+	case *ast.StmtReturn:
 		p.printStmtReturn(n)
-	case *stmt.StaticVar:
+	case *ast.StmtStaticVar:
 		p.printStmtStaticVar(n)
-	case *stmt.Static:
+	case *ast.StmtStatic:
 		p.printStmtStatic(n)
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		p.printStmtStmtList(n)
-	case *stmt.Switch:
+	case *ast.StmtSwitch:
 		p.printStmtSwitch(n)
-	case *stmt.Throw:
+	case *ast.StmtThrow:
 		p.printStmtThrow(n)
-	case *stmt.TraitMethodRef:
+	case *ast.StmtTraitMethodRef:
 		p.printStmtTraitMethodRef(n)
-	case *stmt.TraitUseAlias:
+	case *ast.StmtTraitUseAlias:
 		p.printStmtTraitUseAlias(n)
-	case *stmt.TraitUsePrecedence:
+	case *ast.StmtTraitUsePrecedence:
 		p.printStmtTraitUsePrecedence(n)
-	case *stmt.TraitUse:
+	case *ast.StmtTraitUse:
 		p.printStmtTraitUse(n)
-	case *stmt.Trait:
+	case *ast.StmtTrait:
 		p.printStmtTrait(n)
-	case *stmt.Try:
+	case *ast.StmtTry:
 		p.printStmtTry(n)
-	case *stmt.Unset:
+	case *ast.StmtUnset:
 		p.printStmtUnset(n)
-	case *stmt.UseList:
+	case *ast.StmtUseList:
 		p.printStmtUseList(n)
-	case *stmt.Use:
+	case *ast.StmtUse:
 		p.printStmtUse(n)
-	case *stmt.While:
+	case *ast.StmtWhile:
 		p.printStmtWhile(n)
 	}
 }
 
 // node
 
-func (p *PrettyPrinter) printNodeRoot(n node.Node) {
-	v := n.(*node.Root)
+func (p *PrettyPrinter) printNodeRoot(n ast.Vertex) {
+	v := n.(*ast.Root)
 
 	if len(v.Stmts) > 0 {
 		firstStmt := v.Stmts[0]
 		v.Stmts = v.Stmts[1:]
 
 		switch fs := firstStmt.(type) {
-		case *stmt.InlineHtml:
-			io.WriteString(p.w, fs.Value)
+		case *ast.StmtInlineHtml:
+			io.WriteString(p.w, string(fs.Value))
 			io.WriteString(p.w, "<?php\n")
 		default:
 			io.WriteString(p.w, "<?php\n")
@@ -437,16 +429,16 @@ func (p *PrettyPrinter) printNodeRoot(n node.Node) {
 	io.WriteString(p.w, "\n")
 }
 
-func (p *PrettyPrinter) printNodeIdentifier(n node.Node) {
-	v := n.(*node.Identifier).Value
+func (p *PrettyPrinter) printNodeIdentifier(n ast.Vertex) {
+	v := string(n.(*ast.Identifier).Value)
 	io.WriteString(p.w, v)
 }
 
-func (p *PrettyPrinter) printNodeParameter(n node.Node) {
-	nn := n.(*node.Parameter)
+func (p *PrettyPrinter) printNodeParameter(n ast.Vertex) {
+	nn := n.(*ast.Parameter)
 
-	if nn.VariableType != nil {
-		p.Print(nn.VariableType)
+	if nn.Type != nil {
+		p.Print(nn.Type)
 		io.WriteString(p.w, " ")
 	}
 
@@ -458,7 +450,7 @@ func (p *PrettyPrinter) printNodeParameter(n node.Node) {
 		io.WriteString(p.w, "...")
 	}
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 
 	if nn.DefaultValue != nil {
 		io.WriteString(p.w, " = ")
@@ -466,15 +458,15 @@ func (p *PrettyPrinter) printNodeParameter(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printNodeNullable(n node.Node) {
-	nn := n.(*node.Nullable)
+func (p *PrettyPrinter) printNodeNullable(n ast.Vertex) {
+	nn := n.(*ast.Nullable)
 
 	io.WriteString(p.w, "?")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printNodeArgument(n node.Node) {
-	nn := n.(*node.Argument)
+func (p *PrettyPrinter) printNodeArgument(n ast.Vertex) {
+	nn := n.(*ast.Argument)
 
 	if nn.IsReference {
 		io.WriteString(p.w, "&")
@@ -489,13 +481,13 @@ func (p *PrettyPrinter) printNodeArgument(n node.Node) {
 
 // name
 
-func (p *PrettyPrinter) printNameNamePart(n node.Node) {
-	v := n.(*name.NamePart).Value
+func (p *PrettyPrinter) printNameNamePart(n ast.Vertex) {
+	v := string(n.(*ast.NameNamePart).Value)
 	io.WriteString(p.w, v)
 }
 
-func (p *PrettyPrinter) printNameName(n node.Node) {
-	nn := n.(*name.Name)
+func (p *PrettyPrinter) printNameName(n ast.Vertex) {
+	nn := n.(*ast.NameName)
 
 	for k, part := range nn.Parts {
 		if k > 0 {
@@ -506,8 +498,8 @@ func (p *PrettyPrinter) printNameName(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printNameFullyQualified(n node.Node) {
-	nn := n.(*name.FullyQualified)
+func (p *PrettyPrinter) printNameFullyQualified(n ast.Vertex) {
+	nn := n.(*ast.NameFullyQualified)
 
 	for _, part := range nn.Parts {
 		io.WriteString(p.w, "\\")
@@ -515,8 +507,8 @@ func (p *PrettyPrinter) printNameFullyQualified(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printNameRelative(n node.Node) {
-	nn := n.(*name.Relative)
+func (p *PrettyPrinter) printNameRelative(n ast.Vertex) {
+	nn := n.(*ast.NameRelative)
 
 	io.WriteString(p.w, "namespace")
 	for _, part := range nn.Parts {
@@ -527,34 +519,34 @@ func (p *PrettyPrinter) printNameRelative(n node.Node) {
 
 // scalar
 
-func (p *PrettyPrinter) printScalarLNumber(n node.Node) {
-	v := n.(*scalar.Lnumber).Value
+func (p *PrettyPrinter) printScalarLNumber(n ast.Vertex) {
+	v := string(n.(*ast.ScalarLnumber).Value)
 	io.WriteString(p.w, v)
 }
 
-func (p *PrettyPrinter) printScalarDNumber(n node.Node) {
-	v := n.(*scalar.Dnumber).Value
+func (p *PrettyPrinter) printScalarDNumber(n ast.Vertex) {
+	v := string(n.(*ast.ScalarDnumber).Value)
 	io.WriteString(p.w, v)
 }
 
-func (p *PrettyPrinter) printScalarString(n node.Node) {
-	v := n.(*scalar.String).Value
+func (p *PrettyPrinter) printScalarString(n ast.Vertex) {
+	v := string(n.(*ast.ScalarString).Value)
 
 	io.WriteString(p.w, v)
 }
 
-func (p *PrettyPrinter) printScalarEncapsedStringPart(n node.Node) {
-	v := n.(*scalar.EncapsedStringPart).Value
+func (p *PrettyPrinter) printScalarEncapsedStringPart(n ast.Vertex) {
+	v := string(n.(*ast.ScalarEncapsedStringPart).Value)
 	io.WriteString(p.w, v)
 }
 
-func (p *PrettyPrinter) printScalarEncapsed(n node.Node) {
-	nn := n.(*scalar.Encapsed)
+func (p *PrettyPrinter) printScalarEncapsed(n ast.Vertex) {
+	nn := n.(*ast.ScalarEncapsed)
 	io.WriteString(p.w, "\"")
 
 	for _, part := range nn.Parts {
 		switch part.(type) {
-		case *scalar.EncapsedStringPart:
+		case *ast.ScalarEncapsedStringPart:
 			p.Print(part)
 		default:
 			io.WriteString(p.w, "{")
@@ -566,14 +558,14 @@ func (p *PrettyPrinter) printScalarEncapsed(n node.Node) {
 	io.WriteString(p.w, "\"")
 }
 
-func (p *PrettyPrinter) printScalarHeredoc(n node.Node) {
-	nn := n.(*scalar.Heredoc)
+func (p *PrettyPrinter) printScalarHeredoc(n ast.Vertex) {
+	nn := n.(*ast.ScalarHeredoc)
 
-	io.WriteString(p.w, nn.Label)
+	io.WriteString(p.w, string(nn.Label))
 
 	for _, part := range nn.Parts {
 		switch part.(type) {
-		case *scalar.EncapsedStringPart:
+		case *ast.ScalarEncapsedStringPart:
 			p.Print(part)
 		default:
 			io.WriteString(p.w, "{")
@@ -582,326 +574,326 @@ func (p *PrettyPrinter) printScalarHeredoc(n node.Node) {
 		}
 	}
 
-	io.WriteString(p.w, strings.Trim(nn.Label, "<\"'\n"))
+	io.WriteString(p.w, strings.Trim(string(nn.Label), "<\"'\n"))
 }
 
-func (p *PrettyPrinter) printScalarMagicConstant(n node.Node) {
-	v := n.(*scalar.MagicConstant).Value
+func (p *PrettyPrinter) printScalarMagicConstant(n ast.Vertex) {
+	v := string(n.(*ast.ScalarMagicConstant).Value)
 	io.WriteString(p.w, v)
 }
 
 // Assign
 
-func (p *PrettyPrinter) printAssign(n node.Node) {
-	nn := n.(*assign.Assign)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignAssign(n ast.Vertex) {
+	nn := n.(*ast.ExprAssign)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " = ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printReference(n node.Node) {
-	nn := n.(*assign.Reference)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignReference(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignReference)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " =& ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignBitwiseAnd(n node.Node) {
-	nn := n.(*assign.BitwiseAnd)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignBitwiseAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignBitwiseAnd)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " &= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignBitwiseOr(n node.Node) {
-	nn := n.(*assign.BitwiseOr)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignBitwiseOr(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignBitwiseOr)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " |= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignBitwiseXor(n node.Node) {
-	nn := n.(*assign.BitwiseXor)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignBitwiseXor(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignBitwiseXor)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " ^= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignConcat(n node.Node) {
-	nn := n.(*assign.Concat)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignConcat(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignConcat)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " .= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignDiv(n node.Node) {
-	nn := n.(*assign.Div)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignDiv(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignDiv)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " /= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignMinus(n node.Node) {
-	nn := n.(*assign.Minus)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignMinus(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignMinus)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " -= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignMod(n node.Node) {
-	nn := n.(*assign.Mod)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignMod(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignMod)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " %= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignMul(n node.Node) {
-	nn := n.(*assign.Mul)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignMul(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignMul)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " *= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignPlus(n node.Node) {
-	nn := n.(*assign.Plus)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignPlus(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignPlus)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " += ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignPow(n node.Node) {
-	nn := n.(*assign.Pow)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignPow(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignPow)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " **= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignShiftLeft(n node.Node) {
-	nn := n.(*assign.ShiftLeft)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignShiftLeft(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignShiftLeft)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " <<= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printAssignShiftRight(n node.Node) {
-	nn := n.(*assign.ShiftRight)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignShiftRight(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignShiftRight)
+	p.Print(nn.Var)
 	io.WriteString(p.w, " >>= ")
-	p.Print(nn.Expression)
+	p.Print(nn.Expr)
 }
 
 // binary
 
-func (p *PrettyPrinter) printBinaryBitwiseAnd(n node.Node) {
-	nn := n.(*binary.BitwiseAnd)
+func (p *PrettyPrinter) printBinaryBitwiseAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBitwiseAnd)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " & ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryBitwiseOr(n node.Node) {
-	nn := n.(*binary.BitwiseOr)
+func (p *PrettyPrinter) printBinaryBitwiseOr(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBitwiseOr)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " | ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryBitwiseXor(n node.Node) {
-	nn := n.(*binary.BitwiseXor)
+func (p *PrettyPrinter) printBinaryBitwiseXor(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBitwiseXor)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " ^ ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryBooleanAnd(n node.Node) {
-	nn := n.(*binary.BooleanAnd)
+func (p *PrettyPrinter) printBinaryBooleanAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBooleanAnd)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " && ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryBooleanOr(n node.Node) {
-	nn := n.(*binary.BooleanOr)
+func (p *PrettyPrinter) printBinaryBooleanOr(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBooleanOr)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " || ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryCoalesce(n node.Node) {
-	nn := n.(*binary.Coalesce)
+func (p *PrettyPrinter) printBinaryCoalesce(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryCoalesce)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " ?? ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryConcat(n node.Node) {
-	nn := n.(*binary.Concat)
+func (p *PrettyPrinter) printBinaryConcat(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryConcat)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " . ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryDiv(n node.Node) {
-	nn := n.(*binary.Div)
+func (p *PrettyPrinter) printBinaryDiv(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryDiv)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " / ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryEqual(n node.Node) {
-	nn := n.(*binary.Equal)
+func (p *PrettyPrinter) printBinaryEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryEqual)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " == ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryGreaterOrEqual(n node.Node) {
-	nn := n.(*binary.GreaterOrEqual)
+func (p *PrettyPrinter) printBinaryGreaterOrEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryGreaterOrEqual)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " >= ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryGreater(n node.Node) {
-	nn := n.(*binary.Greater)
+func (p *PrettyPrinter) printBinaryGreater(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryGreater)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " > ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryIdentical(n node.Node) {
-	nn := n.(*binary.Identical)
+func (p *PrettyPrinter) printBinaryIdentical(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryIdentical)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " === ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryLogicalAnd(n node.Node) {
-	nn := n.(*binary.LogicalAnd)
+func (p *PrettyPrinter) printBinaryLogicalAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryLogicalAnd)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " and ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryLogicalOr(n node.Node) {
-	nn := n.(*binary.LogicalOr)
+func (p *PrettyPrinter) printBinaryLogicalOr(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryLogicalOr)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " or ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryLogicalXor(n node.Node) {
-	nn := n.(*binary.LogicalXor)
+func (p *PrettyPrinter) printBinaryLogicalXor(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryLogicalXor)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " xor ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryMinus(n node.Node) {
-	nn := n.(*binary.Minus)
+func (p *PrettyPrinter) printBinaryMinus(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryMinus)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " - ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryMod(n node.Node) {
-	nn := n.(*binary.Mod)
+func (p *PrettyPrinter) printBinaryMod(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryMod)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " % ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryMul(n node.Node) {
-	nn := n.(*binary.Mul)
+func (p *PrettyPrinter) printBinaryMul(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryMul)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " * ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryNotEqual(n node.Node) {
-	nn := n.(*binary.NotEqual)
+func (p *PrettyPrinter) printBinaryNotEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryNotEqual)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " != ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryNotIdentical(n node.Node) {
-	nn := n.(*binary.NotIdentical)
+func (p *PrettyPrinter) printBinaryNotIdentical(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryNotIdentical)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " !== ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryPlus(n node.Node) {
-	nn := n.(*binary.Plus)
+func (p *PrettyPrinter) printBinaryPlus(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryPlus)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " + ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryPow(n node.Node) {
-	nn := n.(*binary.Pow)
+func (p *PrettyPrinter) printBinaryPow(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryPow)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " ** ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryShiftLeft(n node.Node) {
-	nn := n.(*binary.ShiftLeft)
+func (p *PrettyPrinter) printBinaryShiftLeft(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryShiftLeft)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " << ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinaryShiftRight(n node.Node) {
-	nn := n.(*binary.ShiftRight)
+func (p *PrettyPrinter) printBinaryShiftRight(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryShiftRight)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " >> ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinarySmallerOrEqual(n node.Node) {
-	nn := n.(*binary.SmallerOrEqual)
+func (p *PrettyPrinter) printBinarySmallerOrEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinarySmallerOrEqual)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " <= ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinarySmaller(n node.Node) {
-	nn := n.(*binary.Smaller)
+func (p *PrettyPrinter) printBinarySmaller(n ast.Vertex) {
+	nn := n.(*ast.ExprBinarySmaller)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " < ")
 	p.Print(nn.Right)
 }
 
-func (p *PrettyPrinter) printBinarySpaceship(n node.Node) {
-	nn := n.(*binary.Spaceship)
+func (p *PrettyPrinter) printBinarySpaceship(n ast.Vertex) {
+	nn := n.(*ast.ExprBinarySpaceship)
 
 	p.Print(nn.Left)
 	io.WriteString(p.w, " <=> ")
@@ -910,50 +902,50 @@ func (p *PrettyPrinter) printBinarySpaceship(n node.Node) {
 
 // cast
 
-func (p *PrettyPrinter) printArray(n node.Node) {
-	nn := n.(*cast.Array)
+func (p *PrettyPrinter) printArray(n ast.Vertex) {
+	nn := n.(*ast.ExprCastArray)
 
 	io.WriteString(p.w, "(array)")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printBool(n node.Node) {
-	nn := n.(*cast.Bool)
+func (p *PrettyPrinter) printBool(n ast.Vertex) {
+	nn := n.(*ast.ExprCastBool)
 
 	io.WriteString(p.w, "(bool)")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printDouble(n node.Node) {
-	nn := n.(*cast.Double)
+func (p *PrettyPrinter) printDouble(n ast.Vertex) {
+	nn := n.(*ast.ExprCastDouble)
 
 	io.WriteString(p.w, "(float)")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printInt(n node.Node) {
-	nn := n.(*cast.Int)
+func (p *PrettyPrinter) printInt(n ast.Vertex) {
+	nn := n.(*ast.ExprCastInt)
 
 	io.WriteString(p.w, "(int)")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printObject(n node.Node) {
-	nn := n.(*cast.Object)
+func (p *PrettyPrinter) printObject(n ast.Vertex) {
+	nn := n.(*ast.ExprCastObject)
 
 	io.WriteString(p.w, "(object)")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printString(n node.Node) {
-	nn := n.(*cast.String)
+func (p *PrettyPrinter) printString(n ast.Vertex) {
+	nn := n.(*ast.ExprCastString)
 
 	io.WriteString(p.w, "(string)")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printUnset(n node.Node) {
-	nn := n.(*cast.Unset)
+func (p *PrettyPrinter) printUnset(n ast.Vertex) {
+	nn := n.(*ast.ExprCastUnset)
 
 	io.WriteString(p.w, "(unset)")
 	p.Print(nn.Expr)
@@ -961,16 +953,16 @@ func (p *PrettyPrinter) printUnset(n node.Node) {
 
 // expr
 
-func (p *PrettyPrinter) printExprArrayDimFetch(n node.Node) {
-	nn := n.(*expr.ArrayDimFetch)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printExprArrayDimFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprArrayDimFetch)
+	p.Print(nn.Var)
 	io.WriteString(p.w, "[")
 	p.Print(nn.Dim)
 	io.WriteString(p.w, "]")
 }
 
-func (p *PrettyPrinter) printExprArrayItem(n node.Node) {
-	nn := n.(*expr.ArrayItem)
+func (p *PrettyPrinter) printExprArrayItem(n ast.Vertex) {
+	nn := n.(*ast.ExprArrayItem)
 
 	if nn.Key != nil {
 		p.Print(nn.Key)
@@ -980,51 +972,51 @@ func (p *PrettyPrinter) printExprArrayItem(n node.Node) {
 	p.Print(nn.Val)
 }
 
-func (p *PrettyPrinter) printExprArray(n node.Node) {
-	nn := n.(*expr.Array)
+func (p *PrettyPrinter) printExprArray(n ast.Vertex) {
+	nn := n.(*ast.ExprArray)
 
 	io.WriteString(p.w, "array(")
 	p.joinPrint(", ", nn.Items)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprBitwiseNot(n node.Node) {
-	nn := n.(*expr.BitwiseNot)
+func (p *PrettyPrinter) printExprBitwiseNot(n ast.Vertex) {
+	nn := n.(*ast.ExprBitwiseNot)
 	io.WriteString(p.w, "~")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprBooleanNot(n node.Node) {
-	nn := n.(*expr.BooleanNot)
+func (p *PrettyPrinter) printExprBooleanNot(n ast.Vertex) {
+	nn := n.(*ast.ExprBooleanNot)
 	io.WriteString(p.w, "!")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprClassConstFetch(n node.Node) {
-	nn := n.(*expr.ClassConstFetch)
+func (p *PrettyPrinter) printExprClassConstFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprClassConstFetch)
 
 	p.Print(nn.Class)
 	io.WriteString(p.w, "::")
-	io.WriteString(p.w, nn.ConstantName.(*node.Identifier).Value)
+	io.WriteString(p.w, string(nn.ConstantName.(*ast.Identifier).Value))
 }
 
-func (p *PrettyPrinter) printExprClone(n node.Node) {
-	nn := n.(*expr.Clone)
+func (p *PrettyPrinter) printExprClone(n ast.Vertex) {
+	nn := n.(*ast.ExprClone)
 
 	io.WriteString(p.w, "clone ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprClosureUse(n node.Node) {
-	nn := n.(*expr.ClosureUse)
+func (p *PrettyPrinter) printExprClosureUse(n ast.Vertex) {
+	nn := n.(*ast.ExprClosureUse)
 
 	io.WriteString(p.w, "use (")
 	p.joinPrint(", ", nn.Uses)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprClosure(n node.Node) {
-	nn := n.(*expr.Closure)
+func (p *PrettyPrinter) printExprClosure(n ast.Vertex) {
+	nn := n.(*ast.ExprClosure)
 
 	if nn.Static {
 		io.WriteString(p.w, "static ")
@@ -1057,37 +1049,37 @@ func (p *PrettyPrinter) printExprClosure(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printExprConstFetch(n node.Node) {
-	nn := n.(*expr.ConstFetch)
+func (p *PrettyPrinter) printExprConstFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprConstFetch)
 
-	p.Print(nn.Constant)
+	p.Print(nn.Const)
 }
 
-func (p *PrettyPrinter) printExprEmpty(n node.Node) {
-	nn := n.(*expr.Empty)
+func (p *PrettyPrinter) printExprEmpty(n ast.Vertex) {
+	nn := n.(*ast.ExprEmpty)
 
 	io.WriteString(p.w, "empty(")
 	p.Print(nn.Expr)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprErrorSuppress(n node.Node) {
-	nn := n.(*expr.ErrorSuppress)
+func (p *PrettyPrinter) printExprErrorSuppress(n ast.Vertex) {
+	nn := n.(*ast.ExprErrorSuppress)
 
 	io.WriteString(p.w, "@")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprEval(n node.Node) {
-	nn := n.(*expr.Eval)
+func (p *PrettyPrinter) printExprEval(n ast.Vertex) {
+	nn := n.(*ast.ExprEval)
 
 	io.WriteString(p.w, "eval(")
 	p.Print(nn.Expr)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprExit(n node.Node) {
-	nn := n.(*expr.Exit)
+func (p *PrettyPrinter) printExprExit(n ast.Vertex) {
+	nn := n.(*ast.ExprExit)
 
 	if nn.Die {
 		io.WriteString(p.w, "die(")
@@ -1098,8 +1090,8 @@ func (p *PrettyPrinter) printExprExit(n node.Node) {
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprFunctionCall(n node.Node) {
-	nn := n.(*expr.FunctionCall)
+func (p *PrettyPrinter) printExprFunctionCall(n ast.Vertex) {
+	nn := n.(*ast.ExprFunctionCall)
 
 	p.Print(nn.Function)
 	io.WriteString(p.w, "(")
@@ -1107,48 +1099,48 @@ func (p *PrettyPrinter) printExprFunctionCall(n node.Node) {
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprInclude(n node.Node) {
-	nn := n.(*expr.Include)
+func (p *PrettyPrinter) printExprInclude(n ast.Vertex) {
+	nn := n.(*ast.ExprInclude)
 
 	io.WriteString(p.w, "include ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprIncludeOnce(n node.Node) {
-	nn := n.(*expr.IncludeOnce)
+func (p *PrettyPrinter) printExprIncludeOnce(n ast.Vertex) {
+	nn := n.(*ast.ExprIncludeOnce)
 
 	io.WriteString(p.w, "include_once ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprInstanceOf(n node.Node) {
-	nn := n.(*expr.InstanceOf)
+func (p *PrettyPrinter) printExprInstanceOf(n ast.Vertex) {
+	nn := n.(*ast.ExprInstanceOf)
 
 	p.Print(nn.Expr)
 	io.WriteString(p.w, " instanceof ")
 	p.Print(nn.Class)
 }
 
-func (p *PrettyPrinter) printExprIsset(n node.Node) {
-	nn := n.(*expr.Isset)
+func (p *PrettyPrinter) printExprIsset(n ast.Vertex) {
+	nn := n.(*ast.ExprIsset)
 
 	io.WriteString(p.w, "isset(")
-	p.joinPrint(", ", nn.Variables)
+	p.joinPrint(", ", nn.Vars)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprList(n node.Node) {
-	nn := n.(*expr.List)
+func (p *PrettyPrinter) printExprList(n ast.Vertex) {
+	nn := n.(*ast.ExprList)
 
 	io.WriteString(p.w, "list(")
 	p.joinPrint(", ", nn.Items)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprMethodCall(n node.Node) {
-	nn := n.(*expr.MethodCall)
+func (p *PrettyPrinter) printExprMethodCall(n ast.Vertex) {
+	nn := n.(*ast.ExprMethodCall)
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 	io.WriteString(p.w, "->")
 	p.Print(nn.Method)
 	io.WriteString(p.w, "(")
@@ -1156,8 +1148,8 @@ func (p *PrettyPrinter) printExprMethodCall(n node.Node) {
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprNew(n node.Node) {
-	nn := n.(*expr.New)
+func (p *PrettyPrinter) printExprNew(n ast.Vertex) {
+	nn := n.(*ast.ExprNew)
 
 	io.WriteString(p.w, "new ")
 	p.Print(nn.Class)
@@ -1169,78 +1161,78 @@ func (p *PrettyPrinter) printExprNew(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printExprPostDec(n node.Node) {
-	nn := n.(*expr.PostDec)
+func (p *PrettyPrinter) printExprPostDec(n ast.Vertex) {
+	nn := n.(*ast.ExprPostDec)
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 	io.WriteString(p.w, "--")
 }
 
-func (p *PrettyPrinter) printExprPostInc(n node.Node) {
-	nn := n.(*expr.PostInc)
+func (p *PrettyPrinter) printExprPostInc(n ast.Vertex) {
+	nn := n.(*ast.ExprPostInc)
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 	io.WriteString(p.w, "++")
 }
 
-func (p *PrettyPrinter) printExprPreDec(n node.Node) {
-	nn := n.(*expr.PreDec)
+func (p *PrettyPrinter) printExprPreDec(n ast.Vertex) {
+	nn := n.(*ast.ExprPreDec)
 
 	io.WriteString(p.w, "--")
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 }
 
-func (p *PrettyPrinter) printExprPreInc(n node.Node) {
-	nn := n.(*expr.PreInc)
+func (p *PrettyPrinter) printExprPreInc(n ast.Vertex) {
+	nn := n.(*ast.ExprPreInc)
 
 	io.WriteString(p.w, "++")
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 }
 
-func (p *PrettyPrinter) printExprPrint(n node.Node) {
-	nn := n.(*expr.Print)
+func (p *PrettyPrinter) printExprPrint(n ast.Vertex) {
+	nn := n.(*ast.ExprPrint)
 
 	io.WriteString(p.w, "print(")
 	p.Print(nn.Expr)
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprPropertyFetch(n node.Node) {
-	nn := n.(*expr.PropertyFetch)
+func (p *PrettyPrinter) printExprPropertyFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprPropertyFetch)
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 	io.WriteString(p.w, "->")
 	p.Print(nn.Property)
 }
 
-func (p *PrettyPrinter) printExprReference(n node.Node) {
-	nn := n.(*expr.Reference)
+func (p *PrettyPrinter) printExprReference(n ast.Vertex) {
+	nn := n.(*ast.ExprReference)
 
 	io.WriteString(p.w, "&")
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 }
 
-func (p *PrettyPrinter) printExprRequire(n node.Node) {
-	nn := n.(*expr.Require)
+func (p *PrettyPrinter) printExprRequire(n ast.Vertex) {
+	nn := n.(*ast.ExprRequire)
 
 	io.WriteString(p.w, "require ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprRequireOnce(n node.Node) {
-	nn := n.(*expr.RequireOnce)
+func (p *PrettyPrinter) printExprRequireOnce(n ast.Vertex) {
+	nn := n.(*ast.ExprRequireOnce)
 
 	io.WriteString(p.w, "require_once ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprShellExec(n node.Node) {
-	nn := n.(*expr.ShellExec)
+func (p *PrettyPrinter) printExprShellExec(n ast.Vertex) {
+	nn := n.(*ast.ExprShellExec)
 
 	io.WriteString(p.w, "`")
 	for _, part := range nn.Parts {
 		switch part.(type) {
-		case *scalar.EncapsedStringPart:
+		case *ast.ScalarEncapsedStringPart:
 			p.Print(part)
 		default:
 			io.WriteString(p.w, "{")
@@ -1251,24 +1243,24 @@ func (p *PrettyPrinter) printExprShellExec(n node.Node) {
 	io.WriteString(p.w, "`")
 }
 
-func (p *PrettyPrinter) printExprShortArray(n node.Node) {
-	nn := n.(*expr.ShortArray)
+func (p *PrettyPrinter) printExprShortArray(n ast.Vertex) {
+	nn := n.(*ast.ExprShortArray)
 
 	io.WriteString(p.w, "[")
 	p.joinPrint(", ", nn.Items)
 	io.WriteString(p.w, "]")
 }
 
-func (p *PrettyPrinter) printExprShortList(n node.Node) {
-	nn := n.(*expr.ShortList)
+func (p *PrettyPrinter) printExprShortList(n ast.Vertex) {
+	nn := n.(*ast.ExprShortList)
 
 	io.WriteString(p.w, "[")
 	p.joinPrint(", ", nn.Items)
 	io.WriteString(p.w, "]")
 }
 
-func (p *PrettyPrinter) printExprStaticCall(n node.Node) {
-	nn := n.(*expr.StaticCall)
+func (p *PrettyPrinter) printExprStaticCall(n ast.Vertex) {
+	nn := n.(*ast.ExprStaticCall)
 
 	p.Print(nn.Class)
 	io.WriteString(p.w, "::")
@@ -1278,16 +1270,16 @@ func (p *PrettyPrinter) printExprStaticCall(n node.Node) {
 	io.WriteString(p.w, ")")
 }
 
-func (p *PrettyPrinter) printExprStaticPropertyFetch(n node.Node) {
-	nn := n.(*expr.StaticPropertyFetch)
+func (p *PrettyPrinter) printExprStaticPropertyFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprStaticPropertyFetch)
 
 	p.Print(nn.Class)
 	io.WriteString(p.w, "::")
 	p.Print(nn.Property)
 }
 
-func (p *PrettyPrinter) printExprTernary(n node.Node) {
-	nn := n.(*expr.Ternary)
+func (p *PrettyPrinter) printExprTernary(n ast.Vertex) {
+	nn := n.(*ast.ExprTernary)
 
 	p.Print(nn.Condition)
 	io.WriteString(p.w, " ?")
@@ -1302,35 +1294,35 @@ func (p *PrettyPrinter) printExprTernary(n node.Node) {
 	p.Print(nn.IfFalse)
 }
 
-func (p *PrettyPrinter) printExprUnaryMinus(n node.Node) {
-	nn := n.(*expr.UnaryMinus)
+func (p *PrettyPrinter) printExprUnaryMinus(n ast.Vertex) {
+	nn := n.(*ast.ExprUnaryMinus)
 
 	io.WriteString(p.w, "-")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprUnaryPlus(n node.Node) {
-	nn := n.(*expr.UnaryPlus)
+func (p *PrettyPrinter) printExprUnaryPlus(n ast.Vertex) {
+	nn := n.(*ast.ExprUnaryPlus)
 
 	io.WriteString(p.w, "+")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprVariable(n node.Node) {
-	nn := n.(*expr.Variable)
+func (p *PrettyPrinter) printExprVariable(n ast.Vertex) {
+	nn := n.(*ast.ExprVariable)
 	io.WriteString(p.w, "$")
 	p.Print(nn.VarName)
 }
 
-func (p *PrettyPrinter) printExprYieldFrom(n node.Node) {
-	nn := n.(*expr.YieldFrom)
+func (p *PrettyPrinter) printExprYieldFrom(n ast.Vertex) {
+	nn := n.(*ast.ExprYieldFrom)
 
 	io.WriteString(p.w, "yield from ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printExprYield(n node.Node) {
-	nn := n.(*expr.Yield)
+func (p *PrettyPrinter) printExprYield(n ast.Vertex) {
+	nn := n.(*ast.ExprYield)
 
 	io.WriteString(p.w, "yield ")
 
@@ -1344,32 +1336,32 @@ func (p *PrettyPrinter) printExprYield(n node.Node) {
 
 // smtm
 
-func (p *PrettyPrinter) printStmtAltElseIf(n node.Node) {
-	nn := n.(*stmt.AltElseIf)
+func (p *PrettyPrinter) printStmtAltElseIf(n ast.Vertex) {
+	nn := n.(*ast.StmtAltElseIf)
 
 	io.WriteString(p.w, "elseif (")
 	p.Print(nn.Cond)
 	io.WriteString(p.w, ") :")
 
-	if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
+	if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
 		io.WriteString(p.w, "\n")
 		p.printNodes(s)
 	}
 }
 
-func (p *PrettyPrinter) printStmtAltElse(n node.Node) {
-	nn := n.(*stmt.AltElse)
+func (p *PrettyPrinter) printStmtAltElse(n ast.Vertex) {
+	nn := n.(*ast.StmtAltElse)
 
 	io.WriteString(p.w, "else :")
 
-	if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
+	if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
 		io.WriteString(p.w, "\n")
 		p.printNodes(s)
 	}
 }
 
-func (p *PrettyPrinter) printStmtAltFor(n node.Node) {
-	nn := n.(*stmt.AltFor)
+func (p *PrettyPrinter) printStmtAltFor(n ast.Vertex) {
+	nn := n.(*ast.StmtAltFor)
 
 	io.WriteString(p.w, "for (")
 	p.joinPrint(", ", nn.Init)
@@ -1379,7 +1371,7 @@ func (p *PrettyPrinter) printStmtAltFor(n node.Node) {
 	p.joinPrint(", ", nn.Loop)
 	io.WriteString(p.w, ") :\n")
 
-	s := nn.Stmt.(*stmt.StmtList)
+	s := nn.Stmt.(*ast.StmtStmtList)
 	p.printNodes(s.Stmts)
 	io.WriteString(p.w, "\n")
 	p.printIndent()
@@ -1387,8 +1379,8 @@ func (p *PrettyPrinter) printStmtAltFor(n node.Node) {
 	io.WriteString(p.w, "endfor;")
 }
 
-func (p *PrettyPrinter) printStmtAltForeach(n node.Node) {
-	nn := n.(*stmt.AltForeach)
+func (p *PrettyPrinter) printStmtAltForeach(n ast.Vertex) {
+	nn := n.(*ast.StmtAltForeach)
 
 	io.WriteString(p.w, "foreach (")
 	p.Print(nn.Expr)
@@ -1399,11 +1391,11 @@ func (p *PrettyPrinter) printStmtAltForeach(n node.Node) {
 		io.WriteString(p.w, " => ")
 	}
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 
 	io.WriteString(p.w, ") :\n")
 
-	s := nn.Stmt.(*stmt.StmtList)
+	s := nn.Stmt.(*ast.StmtStmtList)
 	p.printNodes(s.Stmts)
 
 	io.WriteString(p.w, "\n")
@@ -1411,14 +1403,14 @@ func (p *PrettyPrinter) printStmtAltForeach(n node.Node) {
 	io.WriteString(p.w, "endforeach;")
 }
 
-func (p *PrettyPrinter) printStmtAltIf(n node.Node) {
-	nn := n.(*stmt.AltIf)
+func (p *PrettyPrinter) printStmtAltIf(n ast.Vertex) {
+	nn := n.(*ast.StmtAltIf)
 
 	io.WriteString(p.w, "if (")
 	p.Print(nn.Cond)
 	io.WriteString(p.w, ") :\n")
 
-	s := nn.Stmt.(*stmt.StmtList)
+	s := nn.Stmt.(*ast.StmtStmtList)
 	p.printNodes(s.Stmts)
 
 	for _, elseif := range nn.ElseIf {
@@ -1438,8 +1430,8 @@ func (p *PrettyPrinter) printStmtAltIf(n node.Node) {
 	io.WriteString(p.w, "endif;")
 }
 
-func (p *PrettyPrinter) printStmtAltSwitch(n node.Node) {
-	nn := n.(*stmt.AltSwitch)
+func (p *PrettyPrinter) printStmtAltSwitch(n ast.Vertex) {
+	nn := n.(*ast.StmtAltSwitch)
 
 	io.WriteString(p.w, "switch (")
 	p.Print(nn.Cond)
@@ -1453,14 +1445,14 @@ func (p *PrettyPrinter) printStmtAltSwitch(n node.Node) {
 	io.WriteString(p.w, "endswitch;")
 }
 
-func (p *PrettyPrinter) printStmtAltWhile(n node.Node) {
-	nn := n.(*stmt.AltWhile)
+func (p *PrettyPrinter) printStmtAltWhile(n ast.Vertex) {
+	nn := n.(*ast.StmtAltWhile)
 
 	io.WriteString(p.w, "while (")
 	p.Print(nn.Cond)
 	io.WriteString(p.w, ") :\n")
 
-	s := nn.Stmt.(*stmt.StmtList)
+	s := nn.Stmt.(*ast.StmtStmtList)
 	p.printNodes(s.Stmts)
 
 	io.WriteString(p.w, "\n")
@@ -1468,8 +1460,8 @@ func (p *PrettyPrinter) printStmtAltWhile(n node.Node) {
 	io.WriteString(p.w, "endwhile;")
 }
 
-func (p *PrettyPrinter) printStmtBreak(n node.Node) {
-	nn := n.(*stmt.Break)
+func (p *PrettyPrinter) printStmtBreak(n ast.Vertex) {
+	nn := n.(*ast.StmtBreak)
 
 	io.WriteString(p.w, "break")
 	if nn.Expr != nil {
@@ -1480,8 +1472,8 @@ func (p *PrettyPrinter) printStmtBreak(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtCase(n node.Node) {
-	nn := n.(*stmt.Case)
+func (p *PrettyPrinter) printStmtCase(n ast.Vertex) {
+	nn := n.(*ast.StmtCase)
 
 	io.WriteString(p.w, "case ")
 	p.Print(nn.Cond)
@@ -1493,13 +1485,13 @@ func (p *PrettyPrinter) printStmtCase(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtCatch(n node.Node) {
-	nn := n.(*stmt.Catch)
+func (p *PrettyPrinter) printStmtCatch(n ast.Vertex) {
+	nn := n.(*ast.StmtCatch)
 
 	io.WriteString(p.w, "catch (")
 	p.joinPrint(" | ", nn.Types)
 	io.WriteString(p.w, " ")
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 	io.WriteString(p.w, ") {\n")
 	p.printNodes(nn.Stmts)
 	io.WriteString(p.w, "\n")
@@ -1507,8 +1499,8 @@ func (p *PrettyPrinter) printStmtCatch(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtClassMethod(n node.Node) {
-	nn := n.(*stmt.ClassMethod)
+func (p *PrettyPrinter) printStmtClassMethod(n ast.Vertex) {
+	nn := n.(*ast.StmtClassMethod)
 
 	if nn.Modifiers != nil {
 		p.joinPrint(" ", nn.Modifiers)
@@ -1531,7 +1523,7 @@ func (p *PrettyPrinter) printStmtClassMethod(n node.Node) {
 	}
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, "\n")
 		p.printIndent()
 		io.WriteString(p.w, "{\n")
@@ -1544,8 +1536,8 @@ func (p *PrettyPrinter) printStmtClassMethod(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtClass(n node.Node) {
-	nn := n.(*stmt.Class)
+func (p *PrettyPrinter) printStmtClass(n ast.Vertex) {
+	nn := n.(*ast.StmtClass)
 
 	if nn.Modifiers != nil {
 		p.joinPrint(" ", nn.Modifiers)
@@ -1583,8 +1575,8 @@ func (p *PrettyPrinter) printStmtClass(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtClassConstList(n node.Node) {
-	nn := n.(*stmt.ClassConstList)
+func (p *PrettyPrinter) printStmtClassConstList(n ast.Vertex) {
+	nn := n.(*ast.StmtClassConstList)
 
 	if nn.Modifiers != nil {
 		p.joinPrint(" ", nn.Modifiers)
@@ -1597,16 +1589,16 @@ func (p *PrettyPrinter) printStmtClassConstList(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtConstant(n node.Node) {
-	nn := n.(*stmt.Constant)
+func (p *PrettyPrinter) printStmtConstant(n ast.Vertex) {
+	nn := n.(*ast.StmtConstant)
 
 	p.Print(nn.ConstantName)
 	io.WriteString(p.w, " = ")
 	p.Print(nn.Expr)
 }
 
-func (p *PrettyPrinter) printStmtContinue(n node.Node) {
-	nn := n.(*stmt.Continue)
+func (p *PrettyPrinter) printStmtContinue(n ast.Vertex) {
+	nn := n.(*ast.StmtContinue)
 
 	io.WriteString(p.w, "continue")
 	if nn.Expr != nil {
@@ -1617,18 +1609,18 @@ func (p *PrettyPrinter) printStmtContinue(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtDeclare(n node.Node) {
-	nn := n.(*stmt.Declare)
+func (p *PrettyPrinter) printStmtDeclare(n ast.Vertex) {
+	nn := n.(*ast.StmtDeclare)
 
 	io.WriteString(p.w, "declare(")
 	p.joinPrint(", ", nn.Consts)
 	io.WriteString(p.w, ")")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
@@ -1640,8 +1632,8 @@ func (p *PrettyPrinter) printStmtDeclare(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtDefault(n node.Node) {
-	nn := n.(*stmt.Default)
+func (p *PrettyPrinter) printStmtDefault(n ast.Vertex) {
+	nn := n.(*ast.StmtDefault)
 	io.WriteString(p.w, "default:")
 
 	if len(nn.Stmts) > 0 {
@@ -1650,12 +1642,12 @@ func (p *PrettyPrinter) printStmtDefault(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtDo(n node.Node) {
-	nn := n.(*stmt.Do)
+func (p *PrettyPrinter) printStmtDo(n ast.Vertex) {
+	nn := n.(*ast.StmtDo)
 	io.WriteString(p.w, "do")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 		io.WriteString(p.w, " ")
@@ -1674,25 +1666,25 @@ func (p *PrettyPrinter) printStmtDo(n node.Node) {
 	io.WriteString(p.w, ");")
 }
 
-func (p *PrettyPrinter) printStmtEcho(n node.Node) {
-	nn := n.(*stmt.Echo)
+func (p *PrettyPrinter) printStmtEcho(n ast.Vertex) {
+	nn := n.(*ast.StmtEcho)
 	io.WriteString(p.w, "echo ")
 	p.joinPrint(", ", nn.Exprs)
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtElseif(n node.Node) {
-	nn := n.(*stmt.ElseIf)
+func (p *PrettyPrinter) printStmtElseif(n ast.Vertex) {
+	nn := n.(*ast.StmtElseIf)
 
 	io.WriteString(p.w, "elseif (")
 	p.Print(nn.Cond)
 	io.WriteString(p.w, ")")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
@@ -1704,16 +1696,16 @@ func (p *PrettyPrinter) printStmtElseif(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtElse(n node.Node) {
-	nn := n.(*stmt.Else)
+func (p *PrettyPrinter) printStmtElse(n ast.Vertex) {
+	nn := n.(*ast.StmtElse)
 
 	io.WriteString(p.w, "else")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
@@ -1725,16 +1717,16 @@ func (p *PrettyPrinter) printStmtElse(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtExpression(n node.Node) {
-	nn := n.(*stmt.Expression)
+func (p *PrettyPrinter) printStmtExpression(n ast.Vertex) {
+	nn := n.(*ast.StmtExpression)
 
 	p.Print(nn.Expr)
 
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtFinally(n node.Node) {
-	nn := n.(*stmt.Finally)
+func (p *PrettyPrinter) printStmtFinally(n ast.Vertex) {
+	nn := n.(*ast.StmtFinally)
 
 	io.WriteString(p.w, "finally {\n")
 	p.printNodes(nn.Stmts)
@@ -1743,8 +1735,8 @@ func (p *PrettyPrinter) printStmtFinally(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtFor(n node.Node) {
-	nn := n.(*stmt.For)
+func (p *PrettyPrinter) printStmtFor(n ast.Vertex) {
+	nn := n.(*ast.StmtFor)
 
 	io.WriteString(p.w, "for (")
 	p.joinPrint(", ", nn.Init)
@@ -1755,10 +1747,10 @@ func (p *PrettyPrinter) printStmtFor(n node.Node) {
 	io.WriteString(p.w, ")")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
@@ -1770,8 +1762,8 @@ func (p *PrettyPrinter) printStmtFor(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtForeach(n node.Node) {
-	nn := n.(*stmt.Foreach)
+func (p *PrettyPrinter) printStmtForeach(n ast.Vertex) {
+	nn := n.(*ast.StmtForeach)
 
 	io.WriteString(p.w, "foreach (")
 	p.Print(nn.Expr)
@@ -1782,14 +1774,14 @@ func (p *PrettyPrinter) printStmtForeach(n node.Node) {
 		io.WriteString(p.w, " => ")
 	}
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 	io.WriteString(p.w, ")")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
@@ -1801,8 +1793,8 @@ func (p *PrettyPrinter) printStmtForeach(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtFunction(n node.Node) {
-	nn := n.(*stmt.Function)
+func (p *PrettyPrinter) printStmtFunction(n ast.Vertex) {
+	nn := n.(*ast.StmtFunction)
 
 	io.WriteString(p.w, "function ")
 
@@ -1828,24 +1820,24 @@ func (p *PrettyPrinter) printStmtFunction(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtGlobal(n node.Node) {
-	nn := n.(*stmt.Global)
+func (p *PrettyPrinter) printStmtGlobal(n ast.Vertex) {
+	nn := n.(*ast.StmtGlobal)
 
 	io.WriteString(p.w, "global ")
 	p.joinPrint(", ", nn.Vars)
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtGoto(n node.Node) {
-	nn := n.(*stmt.Goto)
+func (p *PrettyPrinter) printStmtGoto(n ast.Vertex) {
+	nn := n.(*ast.StmtGoto)
 
 	io.WriteString(p.w, "goto ")
 	p.Print(nn.Label)
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtGroupUse(n node.Node) {
-	nn := n.(*stmt.GroupUse)
+func (p *PrettyPrinter) printStmtGroupUse(n ast.Vertex) {
+	nn := n.(*ast.StmtGroupUse)
 
 	io.WriteString(p.w, "use ")
 
@@ -1860,22 +1852,22 @@ func (p *PrettyPrinter) printStmtGroupUse(n node.Node) {
 	io.WriteString(p.w, "};")
 }
 
-func (p *PrettyPrinter) printStmtHaltCompiler(n node.Node) {
+func (p *PrettyPrinter) printStmtHaltCompiler(n ast.Vertex) {
 	io.WriteString(p.w, "__halt_compiler();")
 }
 
-func (p *PrettyPrinter) printStmtIf(n node.Node) {
-	nn := n.(*stmt.If)
+func (p *PrettyPrinter) printStmtIf(n ast.Vertex) {
+	nn := n.(*ast.StmtIf)
 
 	io.WriteString(p.w, "if (")
 	p.Print(nn.Cond)
 	io.WriteString(p.w, ")")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
@@ -1900,16 +1892,16 @@ func (p *PrettyPrinter) printStmtIf(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtInlineHTML(n node.Node) {
-	nn := n.(*stmt.InlineHtml)
+func (p *PrettyPrinter) printStmtInlineHTML(n ast.Vertex) {
+	nn := n.(*ast.StmtInlineHtml)
 
 	io.WriteString(p.w, "?>")
-	io.WriteString(p.w, nn.Value)
+	io.WriteString(p.w, string(nn.Value))
 	io.WriteString(p.w, "<?php")
 }
 
-func (p *PrettyPrinter) printStmtInterface(n node.Node) {
-	nn := n.(*stmt.Interface)
+func (p *PrettyPrinter) printStmtInterface(n ast.Vertex) {
+	nn := n.(*ast.StmtInterface)
 
 	io.WriteString(p.w, "interface")
 
@@ -1932,15 +1924,15 @@ func (p *PrettyPrinter) printStmtInterface(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtLabel(n node.Node) {
-	nn := n.(*stmt.Label)
+func (p *PrettyPrinter) printStmtLabel(n ast.Vertex) {
+	nn := n.(*ast.StmtLabel)
 
 	p.Print(nn.LabelName)
 	io.WriteString(p.w, ":")
 }
 
-func (p *PrettyPrinter) printStmtNamespace(n node.Node) {
-	nn := n.(*stmt.Namespace)
+func (p *PrettyPrinter) printStmtNamespace(n ast.Vertex) {
+	nn := n.(*ast.StmtNamespace)
 
 	io.WriteString(p.w, "namespace")
 
@@ -1960,12 +1952,12 @@ func (p *PrettyPrinter) printStmtNamespace(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtNop(n node.Node) {
+func (p *PrettyPrinter) printStmtNop(n ast.Vertex) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtPropertyList(n node.Node) {
-	nn := n.(*stmt.PropertyList)
+func (p *PrettyPrinter) printStmtPropertyList(n ast.Vertex) {
+	nn := n.(*ast.StmtPropertyList)
 
 	p.joinPrint(" ", nn.Modifiers)
 	io.WriteString(p.w, " ")
@@ -1973,10 +1965,10 @@ func (p *PrettyPrinter) printStmtPropertyList(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtProperty(n node.Node) {
-	nn := n.(*stmt.Property)
+func (p *PrettyPrinter) printStmtProperty(n ast.Vertex) {
+	nn := n.(*ast.StmtProperty)
 
-	p.Print(nn.Variable)
+	p.Print(nn.Var)
 
 	if nn.Expr != nil {
 		io.WriteString(p.w, " = ")
@@ -1984,17 +1976,17 @@ func (p *PrettyPrinter) printStmtProperty(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtReturn(n node.Node) {
-	nn := n.(*stmt.Return)
+func (p *PrettyPrinter) printStmtReturn(n ast.Vertex) {
+	nn := n.(*ast.StmtReturn)
 
 	io.WriteString(p.w, "return ")
 	p.Print(nn.Expr)
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtStaticVar(n node.Node) {
-	nn := n.(*stmt.StaticVar)
-	p.Print(nn.Variable)
+func (p *PrettyPrinter) printStmtStaticVar(n ast.Vertex) {
+	nn := n.(*ast.StmtStaticVar)
+	p.Print(nn.Var)
 
 	if nn.Expr != nil {
 		io.WriteString(p.w, " = ")
@@ -2002,16 +1994,16 @@ func (p *PrettyPrinter) printStmtStaticVar(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtStatic(n node.Node) {
-	nn := n.(*stmt.Static)
+func (p *PrettyPrinter) printStmtStatic(n ast.Vertex) {
+	nn := n.(*ast.StmtStatic)
 
 	io.WriteString(p.w, "static ")
 	p.joinPrint(", ", nn.Vars)
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtStmtList(n node.Node) {
-	nn := n.(*stmt.StmtList)
+func (p *PrettyPrinter) printStmtStmtList(n ast.Vertex) {
+	nn := n.(*ast.StmtStmtList)
 
 	io.WriteString(p.w, "{\n")
 	p.printNodes(nn.Stmts)
@@ -2020,8 +2012,8 @@ func (p *PrettyPrinter) printStmtStmtList(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtSwitch(n node.Node) {
-	nn := n.(*stmt.Switch)
+func (p *PrettyPrinter) printStmtSwitch(n ast.Vertex) {
+	nn := n.(*ast.StmtSwitch)
 
 	io.WriteString(p.w, "switch (")
 	p.Print(nn.Cond)
@@ -2034,24 +2026,24 @@ func (p *PrettyPrinter) printStmtSwitch(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtThrow(n node.Node) {
-	nn := n.(*stmt.Throw)
+func (p *PrettyPrinter) printStmtThrow(n ast.Vertex) {
+	nn := n.(*ast.StmtThrow)
 
 	io.WriteString(p.w, "throw ")
 	p.Print(nn.Expr)
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtTraitMethodRef(n node.Node) {
-	nn := n.(*stmt.TraitMethodRef)
+func (p *PrettyPrinter) printStmtTraitMethodRef(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitMethodRef)
 
 	p.Print(nn.Trait)
 	io.WriteString(p.w, "::")
 	p.Print(nn.Method)
 }
 
-func (p *PrettyPrinter) printStmtTraitUseAlias(n node.Node) {
-	nn := n.(*stmt.TraitUseAlias)
+func (p *PrettyPrinter) printStmtTraitUseAlias(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitUseAlias)
 
 	p.Print(nn.Ref)
 	io.WriteString(p.w, " as")
@@ -2069,8 +2061,8 @@ func (p *PrettyPrinter) printStmtTraitUseAlias(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtTraitUsePrecedence(n node.Node) {
-	nn := n.(*stmt.TraitUsePrecedence)
+func (p *PrettyPrinter) printStmtTraitUsePrecedence(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitUsePrecedence)
 
 	p.Print(nn.Ref)
 	io.WriteString(p.w, " insteadof ")
@@ -2079,13 +2071,13 @@ func (p *PrettyPrinter) printStmtTraitUsePrecedence(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtTraitUse(n node.Node) {
-	nn := n.(*stmt.TraitUse)
+func (p *PrettyPrinter) printStmtTraitUse(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitUse)
 
 	io.WriteString(p.w, "use ")
 	p.joinPrint(", ", nn.Traits)
 
-	if adaptationList, ok := nn.TraitAdaptationList.(*stmt.TraitAdaptationList); ok {
+	if adaptationList, ok := nn.TraitAdaptationList.(*ast.StmtTraitAdaptationList); ok {
 		adaptations := adaptationList.Adaptations
 		io.WriteString(p.w, " {\n")
 		p.printNodes(adaptations)
@@ -2097,8 +2089,8 @@ func (p *PrettyPrinter) printStmtTraitUse(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtTrait(n node.Node) {
-	nn := n.(*stmt.Trait)
+func (p *PrettyPrinter) printStmtTrait(n ast.Vertex) {
+	nn := n.(*ast.StmtTrait)
 
 	io.WriteString(p.w, "trait ")
 	p.Print(nn.TraitName)
@@ -2112,8 +2104,8 @@ func (p *PrettyPrinter) printStmtTrait(n node.Node) {
 	io.WriteString(p.w, "}")
 }
 
-func (p *PrettyPrinter) printStmtTry(n node.Node) {
-	nn := n.(*stmt.Try)
+func (p *PrettyPrinter) printStmtTry(n ast.Vertex) {
+	nn := n.(*ast.StmtTry)
 
 	io.WriteString(p.w, "try {\n")
 	p.printNodes(nn.Stmts)
@@ -2135,16 +2127,16 @@ func (p *PrettyPrinter) printStmtTry(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtUnset(n node.Node) {
-	nn := n.(*stmt.Unset)
+func (p *PrettyPrinter) printStmtUnset(n ast.Vertex) {
+	nn := n.(*ast.StmtUnset)
 
 	io.WriteString(p.w, "unset(")
 	p.joinPrint(", ", nn.Vars)
 	io.WriteString(p.w, ");")
 }
 
-func (p *PrettyPrinter) printStmtUseList(n node.Node) {
-	nn := n.(*stmt.UseList)
+func (p *PrettyPrinter) printStmtUseList(n ast.Vertex) {
+	nn := n.(*ast.StmtUseList)
 
 	io.WriteString(p.w, "use ")
 
@@ -2157,8 +2149,8 @@ func (p *PrettyPrinter) printStmtUseList(n node.Node) {
 	io.WriteString(p.w, ";")
 }
 
-func (p *PrettyPrinter) printStmtUse(n node.Node) {
-	nn := n.(*stmt.Use)
+func (p *PrettyPrinter) printStmtUse(n ast.Vertex) {
+	nn := n.(*ast.StmtUse)
 
 	if nn.UseType != nil {
 		p.Print(nn.UseType)
@@ -2173,18 +2165,18 @@ func (p *PrettyPrinter) printStmtUse(n node.Node) {
 	}
 }
 
-func (p *PrettyPrinter) printStmtWhile(n node.Node) {
-	nn := n.(*stmt.While)
+func (p *PrettyPrinter) printStmtWhile(n ast.Vertex) {
+	nn := n.(*ast.StmtWhile)
 
 	io.WriteString(p.w, "while (")
 	p.Print(nn.Cond)
 	io.WriteString(p.w, ")")
 
 	switch s := nn.Stmt.(type) {
-	case *stmt.Nop:
+	case *ast.StmtNop:
 		p.Print(s)
 		break
-	case *stmt.StmtList:
+	case *ast.StmtStmtList:
 		io.WriteString(p.w, " ")
 		p.Print(s)
 	default:
diff --git a/printer/pretty_printer_test.go b/pkg/printer/pretty_printer_test.go
similarity index 55%
rename from printer/pretty_printer_test.go
rename to pkg/printer/pretty_printer_test.go
index 7eca7f5..0403ba3 100644
--- a/printer/pretty_printer_test.go
+++ b/pkg/printer/pretty_printer_test.go
@@ -4,53 +4,46 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/z7zmey/php-parser/node"
-	"github.com/z7zmey/php-parser/node/expr"
-	"github.com/z7zmey/php-parser/node/expr/assign"
-	"github.com/z7zmey/php-parser/node/expr/binary"
-	"github.com/z7zmey/php-parser/node/expr/cast"
-	"github.com/z7zmey/php-parser/node/name"
-	"github.com/z7zmey/php-parser/node/scalar"
-	"github.com/z7zmey/php-parser/node/stmt"
-	"github.com/z7zmey/php-parser/printer"
+	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/printer"
 )
 
 func TestPrintFile(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "\t")
-	p.Print(&node.Root{
-		Stmts: []node.Node{
-			&stmt.Namespace{
-				NamespaceName: &name.Name{
-					Parts: []node.Node{
-						&name.NamePart{Value: "Foo"},
+	p.Print(&ast.Root{
+		Stmts: []ast.Vertex{
+			&ast.StmtNamespace{
+				NamespaceName: &ast.NameName{
+					Parts: []ast.Vertex{
+						&ast.NameNamePart{Value: []byte("Foo")},
 					},
 				},
 			},
-			&stmt.Class{
-				Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
-				ClassName: &name.Name{
-					Parts: []node.Node{
-						&name.NamePart{Value: "Bar"},
+			&ast.StmtClass{
+				Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+				ClassName: &ast.NameName{
+					Parts: []ast.Vertex{
+						&ast.NameNamePart{Value: []byte("Bar")},
 					},
 				},
-				Extends: &stmt.ClassExtends{
-					ClassName: &name.Name{
-						Parts: []node.Node{
-							&name.NamePart{Value: "Baz"},
+				Extends: &ast.StmtClassExtends{
+					ClassName: &ast.NameName{
+						Parts: []ast.Vertex{
+							&ast.NameNamePart{Value: []byte("Baz")},
 						},
 					},
 				},
-				Stmts: []node.Node{
-					&stmt.ClassMethod{
-						Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
-						MethodName: &node.Identifier{Value: "greet"},
-						Stmt: &stmt.StmtList{
-							Stmts: []node.Node{
-								&stmt.Echo{
-									Exprs: []node.Node{
-										&scalar.String{Value: "'Hello world'"},
+				Stmts: []ast.Vertex{
+					&ast.StmtClassMethod{
+						Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+						MethodName: &ast.Identifier{Value: []byte("greet")},
+						Stmt: &ast.StmtStmtList{
+							Stmts: []ast.Vertex{
+								&ast.StmtEcho{
+									Exprs: []ast.Vertex{
+										&ast.ScalarString{Value: []byte("'Hello world'")},
 									},
 								},
 							},
@@ -82,14 +75,14 @@ func TestPrintFileInlineHtml(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&node.Root{
-		Stmts: []node.Node{
-			&stmt.InlineHtml{Value: "<div>HTML</div>"},
-			&stmt.Expression{
-				Expr: &scalar.Heredoc{
-					Label: "<<<\"LBL\"\n",
-					Parts: []node.Node{
-						&scalar.EncapsedStringPart{Value: "hello world\n"},
+	p.Print(&ast.Root{
+		Stmts: []ast.Vertex{
+			&ast.StmtInlineHtml{Value: []byte("<div>HTML</div>")},
+			&ast.StmtExpression{
+				Expr: &ast.ScalarHeredoc{
+					Label: []byte("<<<\"LBL\"\n"),
+					Parts: []ast.Vertex{
+						&ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
 					},
 				},
 			},
@@ -114,7 +107,7 @@ func TestPrintIdentifier(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&node.Identifier{Value: "test"})
+	p.Print(&ast.Identifier{Value: []byte("test")})
 
 	if o.String() != `test` {
 		t.Errorf("TestPrintIdentifier is failed\n")
@@ -125,12 +118,12 @@ func TestPrintParameter(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&node.Parameter{
+	p.Print(&ast.Parameter{
 		ByRef:        false,
 		Variadic:     true,
-		VariableType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Variable:     &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-		DefaultValue: &scalar.String{Value: "'default'"},
+		Type:         &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Var:          &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+		DefaultValue: &ast.ScalarString{Value: []byte("'default'")},
 	})
 
 	expected := "\\Foo ...$var = 'default'"
@@ -145,13 +138,13 @@ func TestPrintNullable(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&node.Nullable{
-		Expr: &node.Parameter{
+	p.Print(&ast.Nullable{
+		Expr: &ast.Parameter{
 			ByRef:        false,
 			Variadic:     true,
-			VariableType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			Variable:     &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-			DefaultValue: &scalar.String{Value: "'default'"},
+			Type:         &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			Var:          &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+			DefaultValue: &ast.ScalarString{Value: []byte("'default'")},
 		},
 	})
 
@@ -167,10 +160,10 @@ func TestPrintArgument(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&node.Argument{
+	p.Print(&ast.Argument{
 		IsReference: false,
 		Variadic:    true,
-		Expr:        &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+		Expr:        &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := "...$var"
@@ -184,10 +177,10 @@ func TestPrintArgumentByRef(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&node.Argument{
+	p.Print(&ast.Argument{
 		IsReference: true,
 		Variadic:    false,
-		Expr:        &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+		Expr:        &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := "&$var"
@@ -204,8 +197,8 @@ func TestPrintNameNamePart(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&name.NamePart{
-		Value: "foo",
+	p.Print(&ast.NameNamePart{
+		Value: []byte("foo"),
 	})
 
 	expected := "foo"
@@ -220,13 +213,13 @@ func TestPrintNameName(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&name.Name{
-		Parts: []node.Node{
-			&name.NamePart{
-				Value: "Foo",
+	p.Print(&ast.NameName{
+		Parts: []ast.Vertex{
+			&ast.NameNamePart{
+				Value: []byte("Foo"),
 			},
-			&name.NamePart{
-				Value: "Bar",
+			&ast.NameNamePart{
+				Value: []byte("Bar"),
 			},
 		},
 	})
@@ -243,13 +236,13 @@ func TestPrintNameFullyQualified(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&name.FullyQualified{
-		Parts: []node.Node{
-			&name.NamePart{
-				Value: "Foo",
+	p.Print(&ast.NameFullyQualified{
+		Parts: []ast.Vertex{
+			&ast.NameNamePart{
+				Value: []byte("Foo"),
 			},
-			&name.NamePart{
-				Value: "Bar",
+			&ast.NameNamePart{
+				Value: []byte("Bar"),
 			},
 		},
 	})
@@ -266,13 +259,13 @@ func TestPrintNameRelative(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&name.Relative{
-		Parts: []node.Node{
-			&name.NamePart{
-				Value: "Foo",
+	p.Print(&ast.NameRelative{
+		Parts: []ast.Vertex{
+			&ast.NameNamePart{
+				Value: []byte("Foo"),
 			},
-			&name.NamePart{
-				Value: "Bar",
+			&ast.NameNamePart{
+				Value: []byte("Bar"),
 			},
 		},
 	})
@@ -291,7 +284,7 @@ func TestPrintScalarLNumber(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.Lnumber{Value: "1"})
+	p.Print(&ast.ScalarLnumber{Value: []byte("1")})
 
 	if o.String() != `1` {
 		t.Errorf("TestPrintScalarLNumber is failed\n")
@@ -302,7 +295,7 @@ func TestPrintScalarDNumber(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.Dnumber{Value: ".1"})
+	p.Print(&ast.ScalarDnumber{Value: []byte(".1")})
 
 	if o.String() != `.1` {
 		t.Errorf("TestPrintScalarDNumber is failed\n")
@@ -313,7 +306,7 @@ func TestPrintScalarString(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.String{Value: "'hello world'"})
+	p.Print(&ast.ScalarString{Value: []byte("'hello world'")})
 
 	expected := `'hello world'`
 	actual := o.String()
@@ -327,7 +320,7 @@ func TestPrintScalarEncapsedStringPart(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.EncapsedStringPart{Value: "hello world"})
+	p.Print(&ast.ScalarEncapsedStringPart{Value: []byte("hello world")})
 
 	if o.String() != `hello world` {
 		t.Errorf("TestPrintScalarEncapsedStringPart is failed\n")
@@ -338,11 +331,11 @@ func TestPrintScalarEncapsed(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.Encapsed{
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello "},
-			&expr.Variable{VarName: &node.Identifier{Value: "var"}},
-			&scalar.EncapsedStringPart{Value: " world"},
+	p.Print(&ast.ScalarEncapsed{
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+			&ast.ScalarEncapsedStringPart{Value: []byte(" world")},
 		},
 	})
 
@@ -355,12 +348,12 @@ func TestPrintScalarHeredoc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.Heredoc{
-		Label: "<<<LBL\n",
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello "},
-			&expr.Variable{VarName: &node.Identifier{Value: "var"}},
-			&scalar.EncapsedStringPart{Value: " world\n"},
+	p.Print(&ast.ScalarHeredoc{
+		Label: []byte("<<<LBL\n"),
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+			&ast.ScalarEncapsedStringPart{Value: []byte(" world\n")},
 		},
 	})
 
@@ -378,10 +371,10 @@ func TestPrintScalarNowdoc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.Heredoc{
-		Label: "<<<'LBL'\n",
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello world\n"},
+	p.Print(&ast.ScalarHeredoc{
+		Label: []byte("<<<'LBL'\n"),
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
 		},
 	})
 
@@ -399,7 +392,7 @@ func TestPrintScalarMagicConstant(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&scalar.MagicConstant{Value: "__DIR__"})
+	p.Print(&ast.ScalarMagicConstant{Value: []byte("__DIR__")})
 
 	if o.String() != `__DIR__` {
 		t.Errorf("TestPrintScalarMagicConstant is failed\n")
@@ -412,9 +405,9 @@ func TestPrintAssign(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Assign{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssign{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a = $b`
@@ -429,9 +422,9 @@ func TestPrintReference(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Reference{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignReference{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a =& $b`
@@ -446,9 +439,9 @@ func TestPrintAssignBitwiseAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.BitwiseAnd{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignBitwiseAnd{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a &= $b`
@@ -463,9 +456,9 @@ func TestPrintAssignBitwiseOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.BitwiseOr{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignBitwiseOr{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a |= $b`
@@ -480,9 +473,9 @@ func TestPrintAssignBitwiseXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.BitwiseXor{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignBitwiseXor{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a ^= $b`
@@ -497,9 +490,9 @@ func TestPrintAssignConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Concat{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignConcat{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a .= $b`
@@ -514,9 +507,9 @@ func TestPrintAssignDiv(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Div{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignDiv{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a /= $b`
@@ -531,9 +524,9 @@ func TestPrintAssignMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Minus{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignMinus{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a -= $b`
@@ -548,9 +541,9 @@ func TestPrintAssignMod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Mod{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignMod{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a %= $b`
@@ -565,9 +558,9 @@ func TestPrintAssignMul(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Mul{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignMul{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a *= $b`
@@ -582,9 +575,9 @@ func TestPrintAssignPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Plus{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignPlus{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a += $b`
@@ -599,9 +592,9 @@ func TestPrintAssignPow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.Pow{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignPow{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a **= $b`
@@ -616,9 +609,9 @@ func TestPrintAssignShiftLeft(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.ShiftLeft{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignShiftLeft{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a <<= $b`
@@ -633,9 +626,9 @@ func TestPrintAssignShiftRight(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&assign.ShiftRight{
-		Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprAssignShiftRight{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a >>= $b`
@@ -652,9 +645,9 @@ func TestPrintBinaryBitwiseAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.BitwiseAnd{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryBitwiseAnd{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a & $b`
@@ -669,9 +662,9 @@ func TestPrintBinaryBitwiseOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.BitwiseOr{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryBitwiseOr{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a | $b`
@@ -686,9 +679,9 @@ func TestPrintBinaryBitwiseXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.BitwiseXor{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryBitwiseXor{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a ^ $b`
@@ -703,9 +696,9 @@ func TestPrintBinaryBooleanAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.BooleanAnd{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryBooleanAnd{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a && $b`
@@ -720,9 +713,9 @@ func TestPrintBinaryBooleanOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.BooleanOr{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryBooleanOr{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a || $b`
@@ -737,9 +730,9 @@ func TestPrintBinaryCoalesce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Coalesce{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryCoalesce{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a ?? $b`
@@ -754,9 +747,9 @@ func TestPrintBinaryConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Concat{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryConcat{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a . $b`
@@ -771,9 +764,9 @@ func TestPrintBinaryDiv(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Div{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryDiv{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a / $b`
@@ -788,9 +781,9 @@ func TestPrintBinaryEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Equal{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryEqual{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a == $b`
@@ -805,9 +798,9 @@ func TestPrintBinaryGreaterOrEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.GreaterOrEqual{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryGreaterOrEqual{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a >= $b`
@@ -822,9 +815,9 @@ func TestPrintBinaryGreater(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Greater{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryGreater{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a > $b`
@@ -839,9 +832,9 @@ func TestPrintBinaryIdentical(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Identical{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryIdentical{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a === $b`
@@ -856,9 +849,9 @@ func TestPrintBinaryLogicalAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.LogicalAnd{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryLogicalAnd{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a and $b`
@@ -873,9 +866,9 @@ func TestPrintBinaryLogicalOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.LogicalOr{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryLogicalOr{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a or $b`
@@ -890,9 +883,9 @@ func TestPrintBinaryLogicalXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.LogicalXor{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryLogicalXor{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a xor $b`
@@ -907,9 +900,9 @@ func TestPrintBinaryMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Minus{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryMinus{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a - $b`
@@ -924,9 +917,9 @@ func TestPrintBinaryMod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Mod{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryMod{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a % $b`
@@ -941,9 +934,9 @@ func TestPrintBinaryMul(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Mul{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryMul{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a * $b`
@@ -958,9 +951,9 @@ func TestPrintBinaryNotEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.NotEqual{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryNotEqual{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a != $b`
@@ -975,9 +968,9 @@ func TestPrintBinaryNotIdentical(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.NotIdentical{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryNotIdentical{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a !== $b`
@@ -992,9 +985,9 @@ func TestPrintBinaryPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Plus{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryPlus{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a + $b`
@@ -1009,9 +1002,9 @@ func TestPrintBinaryPow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Pow{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryPow{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a ** $b`
@@ -1026,9 +1019,9 @@ func TestPrintBinaryShiftLeft(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.ShiftLeft{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryShiftLeft{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a << $b`
@@ -1043,9 +1036,9 @@ func TestPrintBinaryShiftRight(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.ShiftRight{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinaryShiftRight{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a >> $b`
@@ -1060,9 +1053,9 @@ func TestPrintBinarySmallerOrEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.SmallerOrEqual{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinarySmallerOrEqual{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a <= $b`
@@ -1077,9 +1070,9 @@ func TestPrintBinarySmaller(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Smaller{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinarySmaller{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a < $b`
@@ -1094,9 +1087,9 @@ func TestPrintBinarySpaceship(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&binary.Spaceship{
-		Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprBinarySpaceship{
+		Left:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a <=> $b`
@@ -1113,8 +1106,8 @@ func TestPrintArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.Array{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastArray{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(array)$var`
@@ -1129,8 +1122,8 @@ func TestPrintBool(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.Bool{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastBool{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(bool)$var`
@@ -1145,8 +1138,8 @@ func TestPrintDouble(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.Double{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastDouble{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(float)$var`
@@ -1161,8 +1154,8 @@ func TestPrintInt(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.Int{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastInt{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(int)$var`
@@ -1177,8 +1170,8 @@ func TestPrintObject(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.Object{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastObject{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(object)$var`
@@ -1193,8 +1186,8 @@ func TestPrintString(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.String{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastString{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(string)$var`
@@ -1209,8 +1202,8 @@ func TestPrintUnset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&cast.Unset{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprCastUnset{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `(unset)$var`
@@ -1227,9 +1220,9 @@ func TestPrintExprArrayDimFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ArrayDimFetch{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-		Dim:      &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.ExprArrayDimFetch{
+		Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+		Dim: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `$var[1]`
@@ -1244,9 +1237,9 @@ func TestPrintExprArrayItemWithKey(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ArrayItem{
-		Key: &scalar.String{Value: "'Hello'"},
-		Val: &expr.Variable{VarName: &node.Identifier{Value: "world"}},
+	p.Print(&ast.ExprArrayItem{
+		Key: &ast.ScalarString{Value: []byte("'Hello'")},
+		Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
 	})
 
 	expected := `'Hello' => $world`
@@ -1261,8 +1254,8 @@ func TestPrintExprArrayItem(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ArrayItem{
-		Val: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "world"}}},
+	p.Print(&ast.ExprArrayItem{
+		Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}}},
 	})
 
 	expected := `&$world`
@@ -1277,18 +1270,18 @@ func TestPrintExprArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Array{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Key: &scalar.String{Value: "'Hello'"},
-				Val: &expr.Variable{VarName: &node.Identifier{Value: "world"}},
+	p.Print(&ast.ExprArray{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarString{Value: []byte("'Hello'")},
+				Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
 			},
-			&expr.ArrayItem{
-				Key: &scalar.Lnumber{Value: "2"},
-				Val: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}}},
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarLnumber{Value: []byte("2")},
+				Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
 			},
-			&expr.ArrayItem{
-				Val: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 			},
 		},
 	})
@@ -1305,8 +1298,8 @@ func TestPrintExprBitwiseNot(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.BitwiseNot{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprBitwiseNot{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `~$var`
@@ -1321,8 +1314,8 @@ func TestPrintExprBooleanNot(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.BooleanNot{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprBooleanNot{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `!$var`
@@ -1337,9 +1330,9 @@ func TestPrintExprClassConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ClassConstFetch{
-		Class:        &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-		ConstantName: &node.Identifier{Value: "CONST"},
+	p.Print(&ast.ExprClassConstFetch{
+		Class:        &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+		ConstantName: &ast.Identifier{Value: []byte("CONST")},
 	})
 
 	expected := `$var::CONST`
@@ -1354,8 +1347,8 @@ func TestPrintExprClone(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Clone{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprClone{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `clone $var`
@@ -1370,10 +1363,10 @@ func TestPrintExprClosureUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ClosureUse{
-		Uses: []node.Node{
-			&expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}}},
-			&expr.Variable{VarName: &node.Identifier{Value: "bar"}},
+	p.Print(&ast.ExprClosureUse{
+		Uses: []ast.Vertex{
+			&ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}}},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("bar")}},
 		},
 	})
 
@@ -1389,27 +1382,27 @@ func TestPrintExprClosure(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&expr.Closure{
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.ExprClosure{
 				Static:     true,
 				ReturnsRef: true,
-				Params: []node.Node{
-					&node.Parameter{
+				Params: []ast.Vertex{
+					&ast.Parameter{
 						ByRef:    true,
 						Variadic: false,
-						Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+						Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 					},
 				},
-				ClosureUse: &expr.ClosureUse{
-					Uses: []node.Node{
-						&expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
-						&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				ClosureUse: &ast.ExprClosureUse{
+					Uses: []ast.Vertex{
+						&ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
+						&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 					},
 				},
-				ReturnType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+				ReturnType: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 				},
 			},
 		},
@@ -1431,8 +1424,8 @@ func TestPrintExprConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ConstFetch{
-		Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}},
+	p.Print(&ast.ExprConstFetch{
+		Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}},
 	})
 
 	expected := "null"
@@ -1447,7 +1440,7 @@ func TestPrintEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Empty{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprEmpty{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `empty($var)`
 	actual := o.String()
@@ -1461,7 +1454,7 @@ func TestPrettyPrinterrorSuppress(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ErrorSuppress{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprErrorSuppress{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `@$var`
 	actual := o.String()
@@ -1475,7 +1468,7 @@ func TestPrintEval(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Eval{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprEval{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `eval($var)`
 	actual := o.String()
@@ -1489,7 +1482,7 @@ func TestPrintExit(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Exit{Die: false, Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprExit{Die: false, Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `exit($var)`
 	actual := o.String()
@@ -1503,7 +1496,7 @@ func TestPrintDie(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Exit{Die: true, Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprExit{Die: true, Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `die($var)`
 	actual := o.String()
@@ -1517,20 +1510,20 @@ func TestPrintFunctionCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.FunctionCall{
-		Function: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
+	p.Print(&ast.ExprFunctionCall{
+		Function: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
 					IsReference: true,
-					Expr:        &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expr:        &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
-				&node.Argument{
+				&ast.Argument{
 					Variadic: true,
-					Expr:     &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+					Expr:     &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 				},
 			},
 		},
@@ -1548,7 +1541,7 @@ func TestPrintInclude(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Include{Expr: &scalar.String{Value: "'path'"}})
+	p.Print(&ast.ExprInclude{Expr: &ast.ScalarString{Value: []byte("'path'")}})
 
 	expected := `include 'path'`
 	actual := o.String()
@@ -1562,7 +1555,7 @@ func TestPrintIncludeOnce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.IncludeOnce{Expr: &scalar.String{Value: "'path'"}})
+	p.Print(&ast.ExprIncludeOnce{Expr: &ast.ScalarString{Value: []byte("'path'")}})
 
 	expected := `include_once 'path'`
 	actual := o.String()
@@ -1576,9 +1569,9 @@ func TestPrintInstanceOf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.InstanceOf{
-		Expr:  &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-		Class: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
+	p.Print(&ast.ExprInstanceOf{
+		Expr:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+		Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 	})
 
 	expected := `$var instanceof Foo`
@@ -1593,10 +1586,10 @@ func TestPrintIsset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Isset{
-		Variables: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "a"}},
-			&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprIsset{
+		Vars: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 		},
 	})
 
@@ -1612,19 +1605,19 @@ func TestPrintList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.List{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Val: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.ExprList{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 			},
-			&expr.ArrayItem{
-				Val: &expr.List{
-					Items: []node.Node{
-						&expr.ArrayItem{
-							Val: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprList{
+					Items: []ast.Vertex{
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 						},
-						&expr.ArrayItem{
-							Val: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 						},
 					},
 				},
@@ -1644,16 +1637,16 @@ func TestPrintMethodCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.MethodCall{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
-		Method:   &node.Identifier{Value: "bar"},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.ExprMethodCall{
+		Var:    &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+		Method: &ast.Identifier{Value: []byte("bar")},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
 			},
 		},
@@ -1671,15 +1664,15 @@ func TestPrintNew(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.New{
-		Class: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.ExprNew{
+		Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
 			},
 		},
@@ -1697,8 +1690,8 @@ func TestPrintPostDec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.PostDec{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprPostDec{
+		Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `$var--`
@@ -1713,8 +1706,8 @@ func TestPrintPostInc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.PostInc{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprPostInc{
+		Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `$var++`
@@ -1729,8 +1722,8 @@ func TestPrintPreDec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.PreDec{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprPreDec{
+		Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `--$var`
@@ -1745,8 +1738,8 @@ func TestPrintPreInc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.PreInc{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprPreInc{
+		Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `++$var`
@@ -1761,7 +1754,7 @@ func TestPrintPrint(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Print{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprPrint{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `print($var)`
 	actual := o.String()
@@ -1775,9 +1768,9 @@ func TestPrintPropertyFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.PropertyFetch{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
-		Property: &node.Identifier{Value: "bar"},
+	p.Print(&ast.ExprPropertyFetch{
+		Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+		Property: &ast.Identifier{Value: []byte("bar")},
 	})
 
 	expected := `$foo->bar`
@@ -1792,8 +1785,8 @@ func TestPrintExprReference(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Reference{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
+	p.Print(&ast.ExprReference{
+		Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
 	})
 
 	expected := `&$foo`
@@ -1808,7 +1801,7 @@ func TestPrintRequire(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Require{Expr: &scalar.String{Value: "'path'"}})
+	p.Print(&ast.ExprRequire{Expr: &ast.ScalarString{Value: []byte("'path'")}})
 
 	expected := `require 'path'`
 	actual := o.String()
@@ -1822,7 +1815,7 @@ func TestPrintRequireOnce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.RequireOnce{Expr: &scalar.String{Value: "'path'"}})
+	p.Print(&ast.ExprRequireOnce{Expr: &ast.ScalarString{Value: []byte("'path'")}})
 
 	expected := `require_once 'path'`
 	actual := o.String()
@@ -1836,11 +1829,11 @@ func TestPrintShellExec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ShellExec{
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello "},
-			&expr.Variable{VarName: &node.Identifier{Value: "world"}},
-			&scalar.EncapsedStringPart{Value: "!"},
+	p.Print(&ast.ExprShellExec{
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
+			&ast.ScalarEncapsedStringPart{Value: []byte("!")},
 		},
 	})
 
@@ -1856,18 +1849,18 @@ func TestPrintExprShortArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ShortArray{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Key: &scalar.String{Value: "'Hello'"},
-				Val: &expr.Variable{VarName: &node.Identifier{Value: "world"}},
+	p.Print(&ast.ExprShortArray{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarString{Value: []byte("'Hello'")},
+				Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
 			},
-			&expr.ArrayItem{
-				Key: &scalar.Lnumber{Value: "2"},
-				Val: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}}},
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarLnumber{Value: []byte("2")},
+				Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
 			},
-			&expr.ArrayItem{
-				Val: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 			},
 		},
 	})
@@ -1884,19 +1877,19 @@ func TestPrintShortList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.ShortList{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Val: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.ExprShortList{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 			},
-			&expr.ArrayItem{
-				Val: &expr.List{
-					Items: []node.Node{
-						&expr.ArrayItem{
-							Val: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprList{
+					Items: []ast.Vertex{
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 						},
-						&expr.ArrayItem{
-							Val: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 						},
 					},
 				},
@@ -1916,16 +1909,16 @@ func TestPrintStaticCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.StaticCall{
-		Class: &node.Identifier{Value: "Foo"},
-		Call:  &node.Identifier{Value: "bar"},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.ExprStaticCall{
+		Class: &ast.Identifier{Value: []byte("Foo")},
+		Call:  &ast.Identifier{Value: []byte("bar")},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
 			},
 		},
@@ -1943,9 +1936,9 @@ func TestPrintStaticPropertyFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.StaticPropertyFetch{
-		Class:    &node.Identifier{Value: "Foo"},
-		Property: &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
+	p.Print(&ast.ExprStaticPropertyFetch{
+		Class:    &ast.Identifier{Value: []byte("Foo")},
+		Property: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("bar")}},
 	})
 
 	expected := `Foo::$bar`
@@ -1960,9 +1953,9 @@ func TestPrintTernary(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Ternary{
-		Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.ExprTernary{
+		Condition: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		IfFalse:   &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 	})
 
 	expected := `$a ?: $b`
@@ -1977,10 +1970,10 @@ func TestPrintTernaryFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Ternary{
-		Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "b"}},
-		IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+	p.Print(&ast.ExprTernary{
+		Condition: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		IfTrue:    &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
+		IfFalse:   &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 	})
 
 	expected := `$a ? $b : $c`
@@ -1995,8 +1988,8 @@ func TestPrintUnaryMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.UnaryMinus{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprUnaryMinus{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `-$var`
@@ -2011,8 +2004,8 @@ func TestPrintUnaryPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.UnaryPlus{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprUnaryPlus{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `+$var`
@@ -2027,7 +2020,7 @@ func TestPrintVariable(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Variable{VarName: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+	p.Print(&ast.ExprVariable{VarName: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
 
 	expected := `$$var`
 	actual := o.String()
@@ -2041,8 +2034,8 @@ func TestPrintYieldFrom(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.YieldFrom{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprYieldFrom{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `yield from $var`
@@ -2057,8 +2050,8 @@ func TestPrintYield(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Yield{
-		Value: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprYield{
+		Value: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `yield $var`
@@ -2073,9 +2066,9 @@ func TestPrintYieldFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&expr.Yield{
-		Key:   &expr.Variable{VarName: &node.Identifier{Value: "k"}},
-		Value: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.ExprYield{
+		Key:   &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
+		Value: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `yield $k => $var`
@@ -2092,11 +2085,11 @@ func TestPrintAltElseIf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.AltElseIf{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+	p.Print(&ast.StmtAltElseIf{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 			},
 		},
 	})
@@ -2114,9 +2107,9 @@ func TestPrintAltElseIfEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.AltElseIf{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.StmtList{},
+	p.Print(&ast.StmtAltElseIf{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtStmtList{},
 	})
 
 	expected := `elseif ($a) :`
@@ -2131,10 +2124,10 @@ func TestPrintAltElse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.AltElse{
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+	p.Print(&ast.StmtAltElse{
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 			},
 		},
 	})
@@ -2152,8 +2145,8 @@ func TestPrintAltElseEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.AltElse{
-		Stmt: &stmt.StmtList{},
+	p.Print(&ast.StmtAltElse{
+		Stmt: &ast.StmtStmtList{},
 	})
 
 	expected := `else :`
@@ -2168,21 +2161,21 @@ func TestPrintAltFor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.AltFor{
-				Init: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtAltFor{
+				Init: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
-				Cond: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				Cond: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
-				Loop: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "c"}},
+				Loop: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 				},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
 					},
 				},
 			},
@@ -2205,15 +2198,15 @@ func TestPrintAltForeach(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.AltForeach{
-				Expr:     &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-				Key:      &expr.Variable{VarName: &node.Identifier{Value: "key"}},
-				Variable: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "val"}}},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtAltForeach{
+				Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+				Key:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("key")}},
+				Var:  &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("val")}}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
 					},
 				},
 			},
@@ -2236,33 +2229,33 @@ func TestPrintAltIf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.AltIf{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtAltIf{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
 					},
 				},
-				ElseIf: []node.Node{
-					&stmt.AltElseIf{
-						Cond: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
-						Stmt: &stmt.StmtList{
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+				ElseIf: []ast.Vertex{
+					&ast.StmtAltElseIf{
+						Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
+						Stmt: &ast.StmtStmtList{
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 							},
 						},
 					},
-					&stmt.AltElseIf{
-						Cond: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
-						Stmt: &stmt.StmtList{},
+					&ast.StmtAltElseIf{
+						Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
+						Stmt: &ast.StmtStmtList{},
 					},
 				},
-				Else: &stmt.AltElse{
-					Stmt: &stmt.StmtList{
-						Stmts: []node.Node{
-							&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+				Else: &ast.StmtAltElse{
+					Stmt: &ast.StmtStmtList{
+						Stmts: []ast.Vertex{
+							&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 						},
 					},
 				},
@@ -2291,22 +2284,22 @@ func TestPrintStmtAltSwitch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.AltSwitch{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-				CaseList: &stmt.CaseList{
-					Cases: []node.Node{
-						&stmt.Case{
-							Cond: &scalar.String{Value: "'a'"},
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtAltSwitch{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+				CaseList: &ast.StmtCaseList{
+					Cases: []ast.Vertex{
+						&ast.StmtCase{
+							Cond: &ast.ScalarString{Value: []byte("'a'")},
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 							},
 						},
-						&stmt.Case{
-							Cond: &scalar.String{Value: "'b'"},
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+						&ast.StmtCase{
+							Cond: &ast.ScalarString{Value: []byte("'b'")},
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 							},
 						},
 					},
@@ -2334,13 +2327,13 @@ func TestPrintAltWhile(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.AltWhile{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtAltWhile{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 					},
 				},
 			},
@@ -2363,8 +2356,8 @@ func TestPrintStmtBreak(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Break{
-		Expr: &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.StmtBreak{
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := "break 1;"
@@ -2379,10 +2372,10 @@ func TestPrintStmtCase(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Case{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtCase{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 		},
 	})
 
@@ -2399,9 +2392,9 @@ func TestPrintStmtCaseEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Case{
-		Cond:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmts: []node.Node{},
+	p.Print(&ast.StmtCase{
+		Cond:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmts: []ast.Vertex{},
 	})
 
 	expected := "case $a:"
@@ -2416,16 +2409,16 @@ func TestPrintStmtCatch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Catch{
-				Types: []node.Node{
-					&name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
-					&name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtCatch{
+				Types: []ast.Vertex{
+					&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+					&ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
 				},
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+				Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 				},
 			},
 		},
@@ -2447,26 +2440,26 @@ func TestPrintStmtClassMethod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.ClassMethod{
-		Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
+	p.Print(&ast.StmtClassMethod{
+		Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
 		ReturnsRef: true,
-		MethodName: &node.Identifier{Value: "foo"},
-		Params: []node.Node{
-			&node.Parameter{
+		MethodName: &ast.Identifier{Value: []byte("foo")},
+		Params: []ast.Vertex{
+			&ast.Parameter{
 				ByRef:        true,
-				VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
-				Variable:     &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+				Type:         &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+				Var:          &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
 			},
-			&node.Parameter{
+			&ast.Parameter{
 				Variadic: true,
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 			},
 		},
-		ReturnType: &name.Name{Parts: []node.Node{&name.NamePart{Value: "void"}}},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+		ReturnType: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}}},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 			},
 		},
 	})
@@ -2485,24 +2478,24 @@ func TestPrintStmtAbstractClassMethod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.ClassMethod{
-		Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
+	p.Print(&ast.StmtClassMethod{
+		Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
 		ReturnsRef: true,
-		MethodName: &node.Identifier{Value: "foo"},
-		Params: []node.Node{
-			&node.Parameter{
+		MethodName: &ast.Identifier{Value: []byte("foo")},
+		Params: []ast.Vertex{
+			&ast.Parameter{
 				ByRef:        true,
-				VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
-				Variable:     &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+				Type:         &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+				Var:          &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
 			},
-			&node.Parameter{
+			&ast.Parameter{
 				Variadic: true,
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 			},
 		},
-		ReturnType: &name.Name{Parts: []node.Node{&name.NamePart{Value: "void"}}},
-		Stmt:       &stmt.Nop{},
+		ReturnType: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}}},
+		Stmt:       &ast.StmtNop{},
 	})
 
 	expected := `public function &foo(?int &$a = null, ...$b): void;`
@@ -2517,27 +2510,27 @@ func TestPrintStmtClass(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Class{
-				Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
-				ClassName: &node.Identifier{Value: "Foo"},
-				Extends: &stmt.ClassExtends{
-					ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtClass{
+				Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+				ClassName: &ast.Identifier{Value: []byte("Foo")},
+				Extends: &ast.StmtClassExtends{
+					ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 				},
-				Implements: &stmt.ClassImplements{
-					InterfaceNames: []node.Node{
-						&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
-						&name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+				Implements: &ast.StmtClassImplements{
+					InterfaceNames: []ast.Vertex{
+						&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+						&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
 					},
 				},
-				Stmts: []node.Node{
-					&stmt.ClassConstList{
-						Modifiers: []node.Node{&node.Identifier{Value: "public"}},
-						Consts: []node.Node{
-							&stmt.Constant{
-								ConstantName: &node.Identifier{Value: "FOO"},
-								Expr:         &scalar.String{Value: "'bar'"},
+				Stmts: []ast.Vertex{
+					&ast.StmtClassConstList{
+						Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+						Consts: []ast.Vertex{
+							&ast.StmtConstant{
+								ConstantName: &ast.Identifier{Value: []byte("FOO")},
+								Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 							},
 						},
 					},
@@ -2563,36 +2556,36 @@ func TestPrintStmtAnonymousClass(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Class{
-				Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
-				ArgumentList: &node.ArgumentList{
-					Arguments: []node.Node{
-						&node.Argument{
-							Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtClass{
+				Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+				ArgumentList: &ast.ArgumentList{
+					Arguments: []ast.Vertex{
+						&ast.Argument{
+							Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 						},
-						&node.Argument{
-							Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+						&ast.Argument{
+							Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 						},
 					},
 				},
-				Extends: &stmt.ClassExtends{
-					ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+				Extends: &ast.StmtClassExtends{
+					ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 				},
-				Implements: &stmt.ClassImplements{
-					InterfaceNames: []node.Node{
-						&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
-						&name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+				Implements: &ast.StmtClassImplements{
+					InterfaceNames: []ast.Vertex{
+						&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+						&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
 					},
 				},
-				Stmts: []node.Node{
-					&stmt.ClassConstList{
-						Modifiers: []node.Node{&node.Identifier{Value: "public"}},
-						Consts: []node.Node{
-							&stmt.Constant{
-								ConstantName: &node.Identifier{Value: "FOO"},
-								Expr:         &scalar.String{Value: "'bar'"},
+				Stmts: []ast.Vertex{
+					&ast.StmtClassConstList{
+						Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+						Consts: []ast.Vertex{
+							&ast.StmtConstant{
+								ConstantName: &ast.Identifier{Value: []byte("FOO")},
+								Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 							},
 						},
 					},
@@ -2618,16 +2611,16 @@ func TestPrintStmtClassConstList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.ClassConstList{
-		Modifiers: []node.Node{&node.Identifier{Value: "public"}},
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'a'"},
+	p.Print(&ast.StmtClassConstList{
+		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'a'")},
 			},
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "BAR"},
-				Expr:         &scalar.String{Value: "'b'"},
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("BAR")},
+				Expr:         &ast.ScalarString{Value: []byte("'b'")},
 			},
 		},
 	})
@@ -2644,9 +2637,9 @@ func TestPrintStmtConstant(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Constant{
-		ConstantName: &node.Identifier{Value: "FOO"},
-		Expr:         &scalar.String{Value: "'BAR'"},
+	p.Print(&ast.StmtConstant{
+		ConstantName: &ast.Identifier{Value: []byte("FOO")},
+		Expr:         &ast.ScalarString{Value: []byte("'BAR'")},
 	})
 
 	expected := "FOO = 'BAR'"
@@ -2661,8 +2654,8 @@ func TestPrintStmtContinue(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Continue{
-		Expr: &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.StmtContinue{
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `continue 1;`
@@ -2677,18 +2670,18 @@ func TestPrintStmtDeclareStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Declare{
-				Consts: []node.Node{
-					&stmt.Constant{
-						ConstantName: &node.Identifier{Value: "FOO"},
-						Expr:         &scalar.String{Value: "'bar'"},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtDeclare{
+				Consts: []ast.Vertex{
+					&ast.StmtConstant{
+						ConstantName: &ast.Identifier{Value: []byte("FOO")},
+						Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 					},
 				},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Nop{},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtNop{},
 					},
 				},
 			},
@@ -2711,16 +2704,16 @@ func TestPrintStmtDeclareExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Declare{
-				Consts: []node.Node{
-					&stmt.Constant{
-						ConstantName: &node.Identifier{Value: "FOO"},
-						Expr:         &scalar.String{Value: "'bar'"},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtDeclare{
+				Consts: []ast.Vertex{
+					&ast.StmtConstant{
+						ConstantName: &ast.Identifier{Value: []byte("FOO")},
+						Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 					},
 				},
-				Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+				Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 			},
 		},
 	})
@@ -2740,14 +2733,14 @@ func TestPrintStmtDeclareNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Declare{
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'bar'"},
+	p.Print(&ast.StmtDeclare{
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 			},
 		},
-		Stmt: &stmt.Nop{},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `declare(FOO = 'bar');`
@@ -2762,9 +2755,9 @@ func TestPrintStmtDefalut(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Default{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtDefault{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 		},
 	})
 
@@ -2781,8 +2774,8 @@ func TestPrintStmtDefalutEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Default{
-		Stmts: []node.Node{},
+	p.Print(&ast.StmtDefault{
+		Stmts: []ast.Vertex{},
 	})
 
 	expected := `default:`
@@ -2797,12 +2790,12 @@ func TestPrintStmtDo_Expression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Do{
-				Cond: &scalar.Lnumber{Value: "1"},
-				Stmt: &stmt.Expression{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtDo{
+				Cond: &ast.ScalarLnumber{Value: []byte("1")},
+				Stmt: &ast.StmtExpression{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
 			},
 		},
@@ -2824,13 +2817,13 @@ func TestPrintStmtDo_StmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Do{
-				Cond: &scalar.Lnumber{Value: "1"},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtDo{
+				Cond: &ast.ScalarLnumber{Value: []byte("1")},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 					},
 				},
 			},
@@ -2853,10 +2846,10 @@ func TestPrintStmtEcho(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Echo{
-		Exprs: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "a"}},
-			&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.StmtEcho{
+		Exprs: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 		},
 	})
 
@@ -2872,11 +2865,11 @@ func TestPrintStmtElseIfStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.ElseIf{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+	p.Print(&ast.StmtElseIf{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -2895,9 +2888,9 @@ func TestPrintStmtElseIfExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.ElseIf{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+	p.Print(&ast.StmtElseIf{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 	})
 
 	expected := `elseif ($a)
@@ -2913,9 +2906,9 @@ func TestPrintStmtElseIfNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.ElseIf{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.Nop{},
+	p.Print(&ast.StmtElseIf{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `elseif ($a);`
@@ -2930,10 +2923,10 @@ func TestPrintStmtElseStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Else{
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+	p.Print(&ast.StmtElse{
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -2952,8 +2945,8 @@ func TestPrintStmtElseExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Else{
-		Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+	p.Print(&ast.StmtElse{
+		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 	})
 
 	expected := `else
@@ -2969,8 +2962,8 @@ func TestPrintStmtElseNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Else{
-		Stmt: &stmt.Nop{},
+	p.Print(&ast.StmtElse{
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `else;`
@@ -2985,7 +2978,7 @@ func TestPrintExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}})
+	p.Print(&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}})
 
 	expected := `$a;`
 	actual := o.String()
@@ -2999,11 +2992,11 @@ func TestPrintStmtFinally(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Finally{
-				Stmts: []node.Node{
-					&stmt.Nop{},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtFinally{
+				Stmts: []ast.Vertex{
+					&ast.StmtNop{},
 				},
 			},
 		},
@@ -3025,24 +3018,24 @@ func TestPrintStmtForStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.For{
-				Init: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "a"}},
-					&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtFor{
+				Init: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
-				Cond: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "c"}},
-					&expr.Variable{VarName: &node.Identifier{Value: "d"}},
+				Cond: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}},
 				},
-				Loop: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "e"}},
-					&expr.Variable{VarName: &node.Identifier{Value: "f"}},
+				Loop: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("f")}},
 				},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Nop{},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtNop{},
 					},
 				},
 			},
@@ -3065,19 +3058,19 @@ func TestPrintStmtForExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.For{
-				Init: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtFor{
+				Init: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 				},
-				Cond: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+				Cond: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
-				Loop: []node.Node{
-					&expr.Variable{VarName: &node.Identifier{Value: "c"}},
+				Loop: []ast.Vertex{
+					&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 				},
-				Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+				Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 			},
 		},
 	})
@@ -3097,17 +3090,17 @@ func TestPrintStmtForNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.For{
-		Init: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.StmtFor{
+		Init: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 		},
-		Cond: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+		Cond: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 		},
-		Loop: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "c"}},
+		Loop: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
 		},
-		Stmt: &stmt.Nop{},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `for ($a; $b; $c);`
@@ -3122,14 +3115,14 @@ func TestPrintStmtForeachStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Foreach{
-				Expr:     &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Nop{},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtForeach{
+				Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtNop{},
 					},
 				},
 			},
@@ -3152,13 +3145,13 @@ func TestPrintStmtForeachExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Foreach{
-				Expr:     &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Key:      &expr.Variable{VarName: &node.Identifier{Value: "k"}},
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "v"}},
-				Stmt:     &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtForeach{
+				Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Key:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
+				Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("v")}},
+				Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 			},
 		},
 	})
@@ -3178,11 +3171,11 @@ func TestPrintStmtForeachNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Foreach{
-		Expr:     &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Key:      &expr.Variable{VarName: &node.Identifier{Value: "k"}},
-		Variable: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "v"}}},
-		Stmt:     &stmt.Nop{},
+	p.Print(&ast.StmtForeach{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Key:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
+		Var:  &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("v")}}},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `foreach ($a as $k => &$v);`
@@ -3197,21 +3190,21 @@ func TestPrintStmtFunction(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Function{
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtFunction{
 				ReturnsRef:   true,
-				FunctionName: &node.Identifier{Value: "foo"},
-				Params: []node.Node{
-					&node.Parameter{
+				FunctionName: &ast.Identifier{Value: []byte("foo")},
+				Params: []ast.Vertex{
+					&ast.Parameter{
 						ByRef:    true,
 						Variadic: false,
-						Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+						Var:      &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 					},
 				},
-				ReturnType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Stmts: []node.Node{
-					&stmt.Nop{},
+				ReturnType: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Stmts: []ast.Vertex{
+					&ast.StmtNop{},
 				},
 			},
 		},
@@ -3233,10 +3226,10 @@ func TestPrintStmtGlobal(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Global{
-		Vars: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "a"}},
-			&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.StmtGlobal{
+		Vars: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 		},
 	})
 
@@ -3252,8 +3245,8 @@ func TestPrintStmtGoto(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Goto{
-		Label: &node.Identifier{Value: "FOO"},
+	p.Print(&ast.StmtGoto{
+		Label: &ast.Identifier{Value: []byte("FOO")},
 	})
 
 	expected := `goto FOO;`
@@ -3268,16 +3261,16 @@ func TestPrintStmtGroupUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.GroupUse{
-		UseType: &node.Identifier{Value: "function"},
-		Prefix:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		UseList: []node.Node{
-			&stmt.Use{
-				Use:   &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
-				Alias: &node.Identifier{Value: "Baz"},
+	p.Print(&ast.StmtGroupUse{
+		UseType: &ast.Identifier{Value: []byte("function")},
+		Prefix:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		UseList: []ast.Vertex{
+			&ast.StmtUse{
+				Use:   &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+				Alias: &ast.Identifier{Value: []byte("Baz")},
 			},
-			&stmt.Use{
-				Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+			&ast.StmtUse{
+				Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
 			},
 		},
 	})
@@ -3294,7 +3287,7 @@ func TestPrintHaltCompiler(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.HaltCompiler{})
+	p.Print(&ast.StmtHaltCompiler{})
 
 	expected := `__halt_compiler();`
 	actual := o.String()
@@ -3308,32 +3301,32 @@ func TestPrintIfExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.If{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Stmt: &stmt.Expression{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtIf{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Stmt: &ast.StmtExpression{
+					Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 				},
-				ElseIf: []node.Node{
-					&stmt.ElseIf{
-						Cond: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
-						Stmt: &stmt.StmtList{
-							Stmts: []node.Node{
-								&stmt.Expression{
-									Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}},
+				ElseIf: []ast.Vertex{
+					&ast.StmtElseIf{
+						Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
+						Stmt: &ast.StmtStmtList{
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{
+									Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}},
 								},
 							},
 						},
 					},
-					&stmt.ElseIf{
-						Cond: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
-						Stmt: &stmt.Nop{},
+					&ast.StmtElseIf{
+						Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+						Stmt: &ast.StmtNop{},
 					},
 				},
-				Else: &stmt.Else{
-					Stmt: &stmt.Expression{
-						Expr: &expr.Variable{VarName: &node.Identifier{Value: "f"}},
+				Else: &ast.StmtElse{
+					Stmt: &ast.StmtExpression{
+						Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("f")}},
 					},
 				},
 			},
@@ -3361,14 +3354,14 @@ func TestPrintIfStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.If{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{
-							Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtIf{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{
+							Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 						},
 					},
 				},
@@ -3392,9 +3385,9 @@ func TestPrintIfNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.If{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.Nop{},
+	p.Print(&ast.StmtIf{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `if ($a);`
@@ -3409,8 +3402,8 @@ func TestPrintInlineHtml(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.InlineHtml{
-		Value: "test",
+	p.Print(&ast.StmtInlineHtml{
+		Value: []byte("test"),
 	})
 
 	expected := `?>test<?php`
@@ -3425,24 +3418,24 @@ func TestPrintInterface(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Interface{
-				InterfaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Extends: &stmt.InterfaceExtends{
-					InterfaceNames: []node.Node{
-						&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
-						&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtInterface{
+				InterfaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Extends: &ast.StmtInterfaceExtends{
+					InterfaceNames: []ast.Vertex{
+						&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+						&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 					},
 				},
-				Stmts: []node.Node{
-					&stmt.ClassMethod{
-						Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
-						MethodName: &node.Identifier{Value: "foo"},
-						Params:     []node.Node{},
-						Stmt: &stmt.StmtList{
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+				Stmts: []ast.Vertex{
+					&ast.StmtClassMethod{
+						Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+						MethodName: &ast.Identifier{Value: []byte("foo")},
+						Params:     []ast.Vertex{},
+						Stmt: &ast.StmtStmtList{
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 							},
 						},
 					},
@@ -3471,8 +3464,8 @@ func TestPrintLabel(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Label{
-		LabelName: &node.Identifier{Value: "FOO"},
+	p.Print(&ast.StmtLabel{
+		LabelName: &ast.Identifier{Value: []byte("FOO")},
 	})
 
 	expected := `FOO:`
@@ -3487,8 +3480,8 @@ func TestPrintNamespace(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		NamespaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
+	p.Print(&ast.StmtNamespace{
+		NamespaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 	})
 
 	expected := `namespace Foo;`
@@ -3503,12 +3496,12 @@ func TestPrintNamespaceWithStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Namespace{
-				NamespaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtNamespace{
+				NamespaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 				},
 			},
 		},
@@ -3530,7 +3523,7 @@ func TestPrintNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Nop{})
+	p.Print(&ast.StmtNop{})
 
 	expected := `;`
 	actual := o.String()
@@ -3544,17 +3537,17 @@ func TestPrintPropertyList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.PropertyList{
-		Modifiers: []node.Node{
-			&node.Identifier{Value: "public"},
-			&node.Identifier{Value: "static"},
+	p.Print(&ast.StmtPropertyList{
+		Modifiers: []ast.Vertex{
+			&ast.Identifier{Value: []byte("public")},
+			&ast.Identifier{Value: []byte("static")},
 		},
-		Properties: []node.Node{
-			&stmt.Property{
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+		Properties: []ast.Vertex{
+			&ast.StmtProperty{
+				Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 			},
-			&stmt.Property{
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+			&ast.StmtProperty{
+				Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 			},
 		},
 	})
@@ -3571,9 +3564,9 @@ func TestPrintProperty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Property{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expr:     &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.StmtProperty{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `$a = 1`
@@ -3588,8 +3581,8 @@ func TestPrintReturn(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Return{
-		Expr: &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.StmtReturn{
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `return 1;`
@@ -3604,9 +3597,9 @@ func TestPrintStaticVar(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StaticVar{
-		Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Expr:     &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.StmtStaticVar{
+		Var:  &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `$a = 1`
@@ -3621,13 +3614,13 @@ func TestPrintStatic(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Static{
-		Vars: []node.Node{
-			&stmt.StaticVar{
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+	p.Print(&ast.StmtStatic{
+		Vars: []ast.Vertex{
+			&ast.StmtStaticVar{
+				Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
 			},
-			&stmt.StaticVar{
-				Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+			&ast.StmtStaticVar{
+				Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 			},
 		},
 	})
@@ -3644,10 +3637,10 @@ func TestPrintStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
-			&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
+			&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 		},
 	})
 
@@ -3666,15 +3659,15 @@ func TestPrintStmtListNested(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
-			&stmt.StmtList{
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
-					&stmt.StmtList{
-						Stmts: []node.Node{
-							&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "c"}}},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
+			&ast.StmtStmtList{
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
+					&ast.StmtStmtList{
+						Stmts: []ast.Vertex{
+							&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}}},
 						},
 					},
 				},
@@ -3702,22 +3695,22 @@ func TestPrintStmtSwitch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Switch{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
-				CaseList: &stmt.CaseList{
-					Cases: []node.Node{
-						&stmt.Case{
-							Cond: &scalar.String{Value: "'a'"},
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtSwitch{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+				CaseList: &ast.StmtCaseList{
+					Cases: []ast.Vertex{
+						&ast.StmtCase{
+							Cond: &ast.ScalarString{Value: []byte("'a'")},
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 							},
 						},
-						&stmt.Case{
-							Cond: &scalar.String{Value: "'b'"},
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+						&ast.StmtCase{
+							Cond: &ast.ScalarString{Value: []byte("'b'")},
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 							},
 						},
 					},
@@ -3745,8 +3738,8 @@ func TestPrintStmtThrow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Throw{
-		Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+	p.Print(&ast.StmtThrow{
+		Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
 	})
 
 	expected := `throw $var;`
@@ -3761,9 +3754,9 @@ func TestPrintStmtTraitMethodRef(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.TraitMethodRef{
-		Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitMethodRef{
+		Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Method: &ast.Identifier{Value: []byte("a")},
 	})
 
 	expected := `Foo::a`
@@ -3778,13 +3771,13 @@ func TestPrintStmtTraitUseAlias(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.TraitUseAlias{
-		Ref: &stmt.TraitMethodRef{
-			Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitUseAlias{
+		Ref: &ast.StmtTraitMethodRef{
+			Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			Method: &ast.Identifier{Value: []byte("a")},
 		},
-		Modifier: &node.Identifier{Value: "public"},
-		Alias:    &node.Identifier{Value: "b"},
+		Modifier: &ast.Identifier{Value: []byte("public")},
+		Alias:    &ast.Identifier{Value: []byte("b")},
 	})
 
 	expected := `Foo::a as public b;`
@@ -3799,14 +3792,14 @@ func TestPrintStmtTraitUsePrecedence(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.TraitUsePrecedence{
-		Ref: &stmt.TraitMethodRef{
-			Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitUsePrecedence{
+		Ref: &ast.StmtTraitMethodRef{
+			Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			Method: &ast.Identifier{Value: []byte("a")},
 		},
-		Insteadof: []node.Node{
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+		Insteadof: []ast.Vertex{
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 		},
 	})
 
@@ -3822,10 +3815,10 @@ func TestPrintStmtTraitUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.TraitUse{
-		Traits: []node.Node{
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+	p.Print(&ast.StmtTraitUse{
+		Traits: []ast.Vertex{
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 		},
 	})
 
@@ -3841,21 +3834,21 @@ func TestPrintStmtTraitAdaptations(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.TraitUse{
-				Traits: []node.Node{
-					&name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-					&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtTraitUse{
+				Traits: []ast.Vertex{
+					&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+					&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 				},
-				TraitAdaptationList: &stmt.TraitAdaptationList{
-					Adaptations: []node.Node{
-						&stmt.TraitUseAlias{
-							Ref: &stmt.TraitMethodRef{
-								Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-								Method: &node.Identifier{Value: "a"},
+				TraitAdaptationList: &ast.StmtTraitAdaptationList{
+					Adaptations: []ast.Vertex{
+						&ast.StmtTraitUseAlias{
+							Ref: &ast.StmtTraitMethodRef{
+								Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+								Method: &ast.Identifier{Value: []byte("a")},
 							},
-							Alias: &node.Identifier{Value: "b"},
+							Alias: &ast.Identifier{Value: []byte("b")},
 						},
 					},
 				},
@@ -3879,18 +3872,18 @@ func TestPrintTrait(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Trait{
-				TraitName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Stmts: []node.Node{
-					&stmt.ClassMethod{
-						Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
-						MethodName: &node.Identifier{Value: "foo"},
-						Params:     []node.Node{},
-						Stmt: &stmt.StmtList{
-							Stmts: []node.Node{
-								&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtTrait{
+				TraitName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Stmts: []ast.Vertex{
+					&ast.StmtClassMethod{
+						Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+						MethodName: &ast.Identifier{Value: []byte("foo")},
+						Params:     []ast.Vertex{},
+						Stmt: &ast.StmtStmtList{
+							Stmts: []ast.Vertex{
+								&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 							},
 						},
 					},
@@ -3919,27 +3912,27 @@ func TestPrintStmtTry(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.Try{
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtTry{
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 				},
-				Catches: []node.Node{
-					&stmt.Catch{
-						Types: []node.Node{
-							&name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
-							&name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+				Catches: []ast.Vertex{
+					&ast.StmtCatch{
+						Types: []ast.Vertex{
+							&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+							&ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
 						},
-						Variable: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
-						Stmts: []node.Node{
-							&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+						Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+						Stmts: []ast.Vertex{
+							&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
 						},
 					},
 				},
-				Finally: &stmt.Finally{
-					Stmts: []node.Node{
-						&stmt.Nop{},
+				Finally: &ast.StmtFinally{
+					Stmts: []ast.Vertex{
+						&ast.StmtNop{},
 					},
 				},
 			},
@@ -3968,10 +3961,10 @@ func TestPrintStmtUset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Unset{
-		Vars: []node.Node{
-			&expr.Variable{VarName: &node.Identifier{Value: "a"}},
-			&expr.Variable{VarName: &node.Identifier{Value: "b"}},
+	p.Print(&ast.StmtUnset{
+		Vars: []ast.Vertex{
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+			&ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
 		},
 	})
 
@@ -3987,15 +3980,15 @@ func TestPrintStmtUseList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.UseList{
-		UseType: &node.Identifier{Value: "function"},
-		Uses: []node.Node{
-			&stmt.Use{
-				Use:   &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Alias: &node.Identifier{Value: "Bar"},
+	p.Print(&ast.StmtUseList{
+		UseType: &ast.Identifier{Value: []byte("function")},
+		Uses: []ast.Vertex{
+			&ast.StmtUse{
+				Use:   &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Alias: &ast.Identifier{Value: []byte("Bar")},
 			},
-			&stmt.Use{
-				Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+			&ast.StmtUse{
+				Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 			},
 		},
 	})
@@ -4012,10 +4005,10 @@ func TestPrintUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Use{
-		UseType: &node.Identifier{Value: "function"},
-		Use:     &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Alias:   &node.Identifier{Value: "Bar"},
+	p.Print(&ast.StmtUse{
+		UseType: &ast.Identifier{Value: []byte("function")},
+		Use:     &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Alias:   &ast.Identifier{Value: []byte("Bar")},
 	})
 
 	expected := `function Foo as Bar`
@@ -4030,13 +4023,13 @@ func TestPrintWhileStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.While{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtWhile{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 					},
 				},
 			},
@@ -4059,11 +4052,11 @@ func TestPrintWhileExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.Namespace{
-		Stmts: []node.Node{
-			&stmt.While{
-				Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-				Stmt: &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+	p.Print(&ast.StmtNamespace{
+		Stmts: []ast.Vertex{
+			&ast.StmtWhile{
+				Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+				Stmt: &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
 			},
 		},
 	})
@@ -4083,9 +4076,9 @@ func TestPrintWhileNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrettyPrinter(o, "    ")
-	p.Print(&stmt.While{
-		Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
-		Stmt: &stmt.Nop{},
+	p.Print(&ast.StmtWhile{
+		Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `while ($a);`
diff --git a/pkg/printer/printer.go b/pkg/printer/printer.go
new file mode 100644
index 0000000..421db21
--- /dev/null
+++ b/pkg/printer/printer.go
@@ -0,0 +1,3257 @@
+package printer
+
+import (
+	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/token"
+	"io"
+	"strings"
+)
+
+type printerState int
+
+const (
+	PhpState printerState = iota
+	HtmlState
+)
+
+type Printer struct {
+	w io.Writer
+	s printerState
+}
+
+// NewPrinter -  Constructor for Printer
+func NewPrinter(w io.Writer) *Printer {
+	return &Printer{
+		w: w,
+	}
+}
+
+func (p *Printer) SetState(s printerState) {
+	p.s = s
+}
+
+func (p *Printer) Print(n ast.Vertex) {
+	_, isRoot := n.(*ast.Root)
+	_, isInlineHtml := n.(*ast.StmtInlineHtml)
+	if p.s == HtmlState && !isInlineHtml && !isRoot {
+		if n.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, "<?php ")
+		}
+		p.SetState(PhpState)
+	}
+
+	p.printNode(n)
+}
+
+func (p *Printer) joinPrint(glue string, nn []ast.Vertex) {
+	for k, n := range nn {
+		if k > 0 {
+			io.WriteString(p.w, glue)
+		}
+
+		p.Print(n)
+	}
+}
+
+func (p *Printer) printNodes(nn []ast.Vertex) {
+	for _, n := range nn {
+		p.Print(n)
+	}
+}
+
+func (p *Printer) printFreeFloating(n ast.Vertex, pos token.Position) {
+	if n == nil {
+		return
+	}
+
+	for _, m := range n.GetNode().Tokens[pos] {
+		io.WriteString(p.w, string(m.Value))
+	}
+}
+
+func (p *Printer) printNode(n ast.Vertex) {
+	switch n.(type) {
+
+	// node
+
+	case *ast.Root:
+		p.printNodeRoot(n)
+	case *ast.Identifier:
+		p.printNodeIdentifier(n)
+	case *ast.Parameter:
+		p.printNodeParameter(n)
+	case *ast.Nullable:
+		p.printNodeNullable(n)
+	case *ast.Argument:
+		p.printNodeArgument(n)
+
+	// name
+
+	case *ast.NameNamePart:
+		p.printNameNamePart(n)
+	case *ast.NameName:
+		p.printNameName(n)
+	case *ast.NameFullyQualified:
+		p.printNameFullyQualified(n)
+	case *ast.NameRelative:
+		p.printNameRelative(n)
+
+	// scalar
+
+	case *ast.ScalarLnumber:
+		p.printScalarLNumber(n)
+	case *ast.ScalarDnumber:
+		p.printScalarDNumber(n)
+	case *ast.ScalarString:
+		p.printScalarString(n)
+	case *ast.ScalarEncapsedStringPart:
+		p.printScalarEncapsedStringPart(n)
+	case *ast.ScalarEncapsed:
+		p.printScalarEncapsed(n)
+	case *ast.ScalarHeredoc:
+		p.printScalarHeredoc(n)
+	case *ast.ScalarMagicConstant:
+		p.printScalarMagicConstant(n)
+
+	// assign
+
+	case *ast.ExprAssign:
+		p.printAssign(n)
+	case *ast.ExprAssignReference:
+		p.printAssignReference(n)
+	case *ast.ExprAssignBitwiseAnd:
+		p.printAssignBitwiseAnd(n)
+	case *ast.ExprAssignBitwiseOr:
+		p.printAssignBitwiseOr(n)
+	case *ast.ExprAssignBitwiseXor:
+		p.printAssignBitwiseXor(n)
+	case *ast.ExprAssignCoalesce:
+		p.printAssignCoalesce(n)
+	case *ast.ExprAssignConcat:
+		p.printAssignConcat(n)
+	case *ast.ExprAssignDiv:
+		p.printAssignDiv(n)
+	case *ast.ExprAssignMinus:
+		p.printAssignMinus(n)
+	case *ast.ExprAssignMod:
+		p.printAssignMod(n)
+	case *ast.ExprAssignMul:
+		p.printAssignMul(n)
+	case *ast.ExprAssignPlus:
+		p.printAssignPlus(n)
+	case *ast.ExprAssignPow:
+		p.printAssignPow(n)
+	case *ast.ExprAssignShiftLeft:
+		p.printAssignShiftLeft(n)
+	case *ast.ExprAssignShiftRight:
+		p.printAssignShiftRight(n)
+
+	// binary
+
+	case *ast.ExprBinaryBitwiseAnd:
+		p.printBinaryBitwiseAnd(n)
+	case *ast.ExprBinaryBitwiseOr:
+		p.printBinaryBitwiseOr(n)
+	case *ast.ExprBinaryBitwiseXor:
+		p.printBinaryBitwiseXor(n)
+	case *ast.ExprBinaryBooleanAnd:
+		p.printBinaryBooleanAnd(n)
+	case *ast.ExprBinaryBooleanOr:
+		p.printBinaryBooleanOr(n)
+	case *ast.ExprBinaryCoalesce:
+		p.printBinaryCoalesce(n)
+	case *ast.ExprBinaryConcat:
+		p.printBinaryConcat(n)
+	case *ast.ExprBinaryDiv:
+		p.printBinaryDiv(n)
+	case *ast.ExprBinaryEqual:
+		p.printBinaryEqual(n)
+	case *ast.ExprBinaryGreaterOrEqual:
+		p.printBinaryGreaterOrEqual(n)
+	case *ast.ExprBinaryGreater:
+		p.printBinaryGreater(n)
+	case *ast.ExprBinaryIdentical:
+		p.printBinaryIdentical(n)
+	case *ast.ExprBinaryLogicalAnd:
+		p.printBinaryLogicalAnd(n)
+	case *ast.ExprBinaryLogicalOr:
+		p.printBinaryLogicalOr(n)
+	case *ast.ExprBinaryLogicalXor:
+		p.printBinaryLogicalXor(n)
+	case *ast.ExprBinaryMinus:
+		p.printBinaryMinus(n)
+	case *ast.ExprBinaryMod:
+		p.printBinaryMod(n)
+	case *ast.ExprBinaryMul:
+		p.printBinaryMul(n)
+	case *ast.ExprBinaryNotEqual:
+		p.printBinaryNotEqual(n)
+	case *ast.ExprBinaryNotIdentical:
+		p.printBinaryNotIdentical(n)
+	case *ast.ExprBinaryPlus:
+		p.printBinaryPlus(n)
+	case *ast.ExprBinaryPow:
+		p.printBinaryPow(n)
+	case *ast.ExprBinaryShiftLeft:
+		p.printBinaryShiftLeft(n)
+	case *ast.ExprBinaryShiftRight:
+		p.printBinaryShiftRight(n)
+	case *ast.ExprBinarySmallerOrEqual:
+		p.printBinarySmallerOrEqual(n)
+	case *ast.ExprBinarySmaller:
+		p.printBinarySmaller(n)
+	case *ast.ExprBinarySpaceship:
+		p.printBinarySpaceship(n)
+
+	// cast
+
+	case *ast.ExprCastArray:
+		p.printArray(n)
+	case *ast.ExprCastBool:
+		p.printBool(n)
+	case *ast.ExprCastDouble:
+		p.printDouble(n)
+	case *ast.ExprCastInt:
+		p.printInt(n)
+	case *ast.ExprCastObject:
+		p.printObject(n)
+	case *ast.ExprCastString:
+		p.printString(n)
+	case *ast.ExprCastUnset:
+		p.printUnset(n)
+
+	// expr
+
+	case *ast.ExprArrayDimFetch:
+		p.printExprArrayDimFetch(n)
+	case *ast.ExprArrayItem:
+		p.printExprArrayItem(n)
+	case *ast.ExprArray:
+		p.printExprArray(n)
+	case *ast.ExprArrowFunction:
+		p.printExprArrowFunction(n)
+	case *ast.ExprBitwiseNot:
+		p.printExprBitwiseNot(n)
+	case *ast.ExprBooleanNot:
+		p.printExprBooleanNot(n)
+	case *ast.ExprClassConstFetch:
+		p.printExprClassConstFetch(n)
+	case *ast.ExprClone:
+		p.printExprClone(n)
+	case *ast.ExprClosureUse:
+		p.printExprClosureUse(n)
+	case *ast.ExprClosure:
+		p.printExprClosure(n)
+	case *ast.ExprConstFetch:
+		p.printExprConstFetch(n)
+	case *ast.ExprEmpty:
+		p.printExprEmpty(n)
+	case *ast.ExprErrorSuppress:
+		p.printExprErrorSuppress(n)
+	case *ast.ExprEval:
+		p.printExprEval(n)
+	case *ast.ExprExit:
+		p.printExprExit(n)
+	case *ast.ExprFunctionCall:
+		p.printExprFunctionCall(n)
+	case *ast.ExprInclude:
+		p.printExprInclude(n)
+	case *ast.ExprIncludeOnce:
+		p.printExprIncludeOnce(n)
+	case *ast.ExprInstanceOf:
+		p.printExprInstanceOf(n)
+	case *ast.ExprIsset:
+		p.printExprIsset(n)
+	case *ast.ExprList:
+		p.printExprList(n)
+	case *ast.ExprMethodCall:
+		p.printExprMethodCall(n)
+	case *ast.ExprNew:
+		p.printExprNew(n)
+	case *ast.ExprPostDec:
+		p.printExprPostDec(n)
+	case *ast.ExprPostInc:
+		p.printExprPostInc(n)
+	case *ast.ExprPreDec:
+		p.printExprPreDec(n)
+	case *ast.ExprPreInc:
+		p.printExprPreInc(n)
+	case *ast.ExprPrint:
+		p.printExprPrint(n)
+	case *ast.ExprPropertyFetch:
+		p.printExprPropertyFetch(n)
+	case *ast.ExprReference:
+		p.printExprReference(n)
+	case *ast.ExprRequire:
+		p.printExprRequire(n)
+	case *ast.ExprRequireOnce:
+		p.printExprRequireOnce(n)
+	case *ast.ExprShellExec:
+		p.printExprShellExec(n)
+	case *ast.ExprShortArray:
+		p.printExprShortArray(n)
+	case *ast.ExprShortList:
+		p.printExprShortList(n)
+	case *ast.ExprStaticCall:
+		p.printExprStaticCall(n)
+	case *ast.ExprStaticPropertyFetch:
+		p.printExprStaticPropertyFetch(n)
+	case *ast.ExprTernary:
+		p.printExprTernary(n)
+	case *ast.ExprUnaryMinus:
+		p.printExprUnaryMinus(n)
+	case *ast.ExprUnaryPlus:
+		p.printExprUnaryPlus(n)
+	case *ast.ExprVariable:
+		p.printExprVariable(n)
+	case *ast.ExprYieldFrom:
+		p.printExprYieldFrom(n)
+	case *ast.ExprYield:
+		p.printExprYield(n)
+
+	// stmt
+
+	case *ast.StmtAltElseIf:
+		p.printStmtAltElseIf(n)
+	case *ast.StmtAltElse:
+		p.printStmtAltElse(n)
+	case *ast.StmtAltFor:
+		p.printStmtAltFor(n)
+	case *ast.StmtAltForeach:
+		p.printStmtAltForeach(n)
+	case *ast.StmtAltIf:
+		p.printStmtAltIf(n)
+	case *ast.StmtAltSwitch:
+		p.printStmtAltSwitch(n)
+	case *ast.StmtAltWhile:
+		p.printStmtAltWhile(n)
+	case *ast.StmtBreak:
+		p.printStmtBreak(n)
+	case *ast.StmtCase:
+		p.printStmtCase(n)
+	case *ast.StmtCatch:
+		p.printStmtCatch(n)
+	case *ast.StmtClassMethod:
+		p.printStmtClassMethod(n)
+	case *ast.StmtClass:
+		p.printStmtClass(n)
+	case *ast.StmtClassConstList:
+		p.printStmtClassConstList(n)
+	case *ast.StmtConstList:
+		p.printStmtConstList(n)
+	case *ast.StmtConstant:
+		p.printStmtConstant(n)
+	case *ast.StmtContinue:
+		p.printStmtContinue(n)
+	case *ast.StmtDeclare:
+		p.printStmtDeclare(n)
+	case *ast.StmtDefault:
+		p.printStmtDefault(n)
+	case *ast.StmtDo:
+		p.printStmtDo(n)
+	case *ast.StmtEcho:
+		p.printStmtEcho(n)
+	case *ast.StmtElseIf:
+		p.printStmtElseif(n)
+	case *ast.StmtElse:
+		p.printStmtElse(n)
+	case *ast.StmtExpression:
+		p.printStmtExpression(n)
+	case *ast.StmtFinally:
+		p.printStmtFinally(n)
+	case *ast.StmtFor:
+		p.printStmtFor(n)
+	case *ast.StmtForeach:
+		p.printStmtForeach(n)
+	case *ast.StmtFunction:
+		p.printStmtFunction(n)
+	case *ast.StmtGlobal:
+		p.printStmtGlobal(n)
+	case *ast.StmtGoto:
+		p.printStmtGoto(n)
+	case *ast.StmtGroupUse:
+		p.printStmtGroupUse(n)
+	case *ast.StmtHaltCompiler:
+		p.printStmtHaltCompiler(n)
+	case *ast.StmtIf:
+		p.printStmtIf(n)
+	case *ast.StmtInlineHtml:
+		p.printStmtInlineHTML(n)
+	case *ast.StmtInterface:
+		p.printStmtInterface(n)
+	case *ast.StmtLabel:
+		p.printStmtLabel(n)
+	case *ast.StmtNamespace:
+		p.printStmtNamespace(n)
+	case *ast.StmtNop:
+		p.printStmtNop(n)
+	case *ast.StmtPropertyList:
+		p.printStmtPropertyList(n)
+	case *ast.StmtProperty:
+		p.printStmtProperty(n)
+	case *ast.StmtReturn:
+		p.printStmtReturn(n)
+	case *ast.StmtStaticVar:
+		p.printStmtStaticVar(n)
+	case *ast.StmtStatic:
+		p.printStmtStatic(n)
+	case *ast.StmtStmtList:
+		p.printStmtStmtList(n)
+	case *ast.StmtSwitch:
+		p.printStmtSwitch(n)
+	case *ast.StmtThrow:
+		p.printStmtThrow(n)
+	case *ast.StmtTraitAdaptationList:
+		p.printStmtTraitAdaptationList(n)
+	case *ast.StmtTraitMethodRef:
+		p.printStmtTraitMethodRef(n)
+	case *ast.StmtTraitUseAlias:
+		p.printStmtTraitUseAlias(n)
+	case *ast.StmtTraitUsePrecedence:
+		p.printStmtTraitUsePrecedence(n)
+	case *ast.StmtTraitUse:
+		p.printStmtTraitUse(n)
+	case *ast.StmtTrait:
+		p.printStmtTrait(n)
+	case *ast.StmtTry:
+		p.printStmtTry(n)
+	case *ast.StmtUnset:
+		p.printStmtUnset(n)
+	case *ast.StmtUseList:
+		p.printStmtUseList(n)
+	case *ast.StmtUse:
+		p.printStmtUse(n)
+	case *ast.StmtWhile:
+		p.printStmtWhile(n)
+	}
+}
+
+// node
+
+func (p *Printer) printNodeRoot(n ast.Vertex) {
+	nn := n.(*ast.Root)
+	p.SetState(HtmlState)
+	p.printFreeFloating(nn, token.Start)
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeIdentifier(n ast.Vertex) {
+	nn := n.(*ast.Identifier)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, string(nn.Value))
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeParameter(n ast.Vertex) {
+	nn := n.(*ast.Parameter)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Type != nil {
+		p.Print(nn.Type)
+	}
+	p.printFreeFloating(nn, token.OptionalType)
+
+	if nn.ByRef {
+		io.WriteString(p.w, "&")
+	}
+	p.printFreeFloating(nn, token.Ampersand)
+
+	if nn.Variadic {
+		io.WriteString(p.w, "...")
+	}
+	p.printFreeFloating(nn, token.Variadic)
+
+	p.Print(nn.Var)
+
+	if nn.DefaultValue != nil {
+		p.printFreeFloating(nn, token.Var)
+		io.WriteString(p.w, "=")
+		p.Print(nn.DefaultValue)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeNullable(n ast.Vertex) {
+	nn := n.(*ast.Nullable)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "?")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeArgument(n ast.Vertex) {
+	nn := n.(*ast.Argument)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.IsReference {
+		io.WriteString(p.w, "&")
+	}
+	p.printFreeFloating(nn, token.Ampersand)
+
+	if nn.Variadic {
+		io.WriteString(p.w, "...")
+	}
+	p.printFreeFloating(nn, token.Variadic)
+
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+// name
+
+func (p *Printer) printNameNamePart(n ast.Vertex) {
+	nn := n.(*ast.NameNamePart)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, string(nn.Value))
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNameName(n ast.Vertex) {
+	nn := n.(*ast.NameName)
+	p.printFreeFloating(nn, token.Start)
+
+	p.joinPrint("\\", nn.Parts)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNameFullyQualified(n ast.Vertex) {
+	nn := n.(*ast.NameFullyQualified)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "\\")
+	p.joinPrint("\\", nn.Parts)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNameRelative(n ast.Vertex) {
+	nn := n.(*ast.NameRelative)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "namespace")
+	p.printFreeFloating(nn, token.Namespace)
+
+	for _, part := range nn.Parts {
+		io.WriteString(p.w, "\\")
+		p.Print(part)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+// scalar
+
+func (p *Printer) printScalarLNumber(n ast.Vertex) {
+	nn := n.(*ast.ScalarLnumber)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, string(nn.Value))
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarDNumber(n ast.Vertex) {
+	nn := n.(*ast.ScalarDnumber)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, string(nn.Value))
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarString(n ast.Vertex) {
+	nn := n.(*ast.ScalarString)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, string(nn.Value))
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarEncapsedStringPart(n ast.Vertex) {
+	nn := n.(*ast.ScalarEncapsedStringPart)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, string(nn.Value))
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarEncapsed(n ast.Vertex) {
+	nn := n.(*ast.ScalarEncapsed)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "\"")
+	for _, part := range nn.Parts {
+		switch part.(type) {
+		case *ast.ExprArrayDimFetch:
+			s := part.GetNode().Tokens[token.Start]
+			if len(s) > 0 && string(s[0].Value) == "${" {
+				p.printExprArrayDimFetchWithoutLeadingDollar(part)
+			} else {
+				p.Print(part)
+			}
+		case *ast.ExprVariable:
+			s := part.GetNode().Tokens[token.Start]
+			if len(s) > 0 && string(s[0].Value) == "${" {
+				p.printExprVariableWithoutLeadingDollar(part)
+			} else {
+				p.Print(part)
+			}
+		default:
+			p.Print(part)
+		}
+	}
+	io.WriteString(p.w, "\"")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarHeredoc(n ast.Vertex) {
+	nn := n.(*ast.ScalarHeredoc)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, string(nn.Label))
+
+	for _, part := range nn.Parts {
+		switch part.(type) {
+		case *ast.ExprArrayDimFetch:
+			s := part.GetNode().Tokens[token.Start]
+			if len(s) > 0 && string(s[0].Value) == "${" {
+				p.printExprArrayDimFetchWithoutLeadingDollar(part)
+			} else {
+				p.Print(part)
+			}
+		case *ast.ExprVariable:
+			s := part.GetNode().Tokens[token.Start]
+			if len(s) > 0 && string(s[0].Value) == "${" {
+				p.printExprVariableWithoutLeadingDollar(part)
+			} else {
+				p.Print(part)
+			}
+		default:
+			p.Print(part)
+		}
+	}
+
+	io.WriteString(p.w, strings.Trim(string(nn.Label), "<\"'\n"))
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarMagicConstant(n ast.Vertex) {
+	nn := n.(*ast.ScalarMagicConstant)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, string(nn.Value))
+	p.printFreeFloating(nn, token.End)
+}
+
+// Assign
+
+func (p *Printer) printAssign(n ast.Vertex) {
+	nn := n.(*ast.ExprAssign)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignReference(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignReference)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "=")
+	p.printFreeFloating(nn, token.Equal)
+	io.WriteString(p.w, "&")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignBitwiseAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignBitwiseAnd)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "&")
+	io.WriteString(p.w, "=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignBitwiseOr(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignBitwiseOr)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "|=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignBitwiseXor(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignBitwiseXor)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "^=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignCoalesce(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignCoalesce)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "??=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignConcat(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignConcat)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, ".=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignDiv(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignDiv)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "/=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignMinus(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignMinus)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "-=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignMod(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignMod)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "%=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignMul(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignMul)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "*=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignPlus(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignPlus)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "+=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignPow(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignPow)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "**=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignShiftLeft(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignShiftLeft)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "<<=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignShiftRight(n ast.Vertex) {
+	nn := n.(*ast.ExprAssignShiftRight)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, ">>=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+// binary
+
+func (p *Printer) printBinaryBitwiseAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBitwiseAnd)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "&")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBitwiseOr(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBitwiseOr)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "|")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBitwiseXor(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBitwiseXor)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "^")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBooleanAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBooleanAnd)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "&&")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBooleanOr(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryBooleanOr)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "||")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryCoalesce(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryCoalesce)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "??")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryConcat(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryConcat)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ".")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryDiv(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryDiv)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "/")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryEqual)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "==")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryGreaterOrEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryGreaterOrEqual)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ">=")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryGreater(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryGreater)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ">")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryIdentical(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryIdentical)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "===")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryLogicalAnd(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryLogicalAnd)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	io.WriteString(p.w, "and")
+	if nn.Right.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryLogicalOr(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryLogicalOr)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	io.WriteString(p.w, "or")
+	if nn.Right.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryLogicalXor(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryLogicalXor)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	io.WriteString(p.w, "xor")
+	if nn.Right.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryMinus(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryMinus)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "-")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryMod(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryMod)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "%")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryMul(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryMul)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "*")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryNotEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryNotEqual)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	p.printFreeFloating(nn, token.Equal)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "!=")
+	}
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryNotIdentical(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryNotIdentical)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "!==")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryPlus(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryPlus)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "+")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryPow(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryPow)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "**")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryShiftLeft(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryShiftLeft)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "<<")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryShiftRight(n ast.Vertex) {
+	nn := n.(*ast.ExprBinaryShiftRight)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ">>")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinarySmallerOrEqual(n ast.Vertex) {
+	nn := n.(*ast.ExprBinarySmallerOrEqual)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "<=")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinarySmaller(n ast.Vertex) {
+	nn := n.(*ast.ExprBinarySmaller)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "<")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinarySpaceship(n ast.Vertex) {
+	nn := n.(*ast.ExprBinarySpaceship)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Left)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, "<=>")
+	p.Print(nn.Right)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+// cast
+
+func (p *Printer) printArray(n ast.Vertex) {
+	nn := n.(*ast.ExprCastArray)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(array)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBool(n ast.Vertex) {
+	nn := n.(*ast.ExprCastBool)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(boolean)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printDouble(n ast.Vertex) {
+	nn := n.(*ast.ExprCastDouble)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(float)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printInt(n ast.Vertex) {
+	nn := n.(*ast.ExprCastInt)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(integer)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printObject(n ast.Vertex) {
+	nn := n.(*ast.ExprCastObject)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(object)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printString(n ast.Vertex) {
+	nn := n.(*ast.ExprCastString)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(string)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printUnset(n ast.Vertex) {
+	nn := n.(*ast.ExprCastUnset)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Cast)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "(unset)")
+	}
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+// expr
+
+func (p *Printer) printExprArrayDimFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprArrayDimFetch)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "[")
+	}
+	p.Print(nn.Dim)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "]")
+	}
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArrayDimFetchWithoutLeadingDollar(n ast.Vertex) {
+	nn := n.(*ast.ExprArrayDimFetch)
+	p.printFreeFloating(nn, token.Start)
+	p.printExprVariableWithoutLeadingDollar(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "[")
+	}
+	p.Print(nn.Dim)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "]")
+	}
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArrayItem(n ast.Vertex) {
+	nn := n.(*ast.ExprArrayItem)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Unpack {
+		io.WriteString(p.w, "...")
+	}
+
+	if nn.Key != nil {
+		p.Print(nn.Key)
+		p.printFreeFloating(nn, token.Expr)
+		io.WriteString(p.w, "=>")
+	}
+
+	p.Print(nn.Val)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArray(n ast.Vertex) {
+	nn := n.(*ast.ExprArray)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "array")
+	p.printFreeFloating(nn, token.Array)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Items)
+	p.printFreeFloating(nn, token.ArrayPairList)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArrowFunction(n ast.Vertex) {
+	nn := n.(*ast.ExprArrowFunction)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Static {
+		io.WriteString(p.w, "static")
+	}
+	p.printFreeFloating(nn, token.Static)
+	if nn.Static && n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	io.WriteString(p.w, "fn")
+	p.printFreeFloating(nn, token.Function)
+
+	if nn.ReturnsRef {
+		io.WriteString(p.w, "&")
+	}
+	p.printFreeFloating(nn, token.Ampersand)
+
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Params)
+	p.printFreeFloating(nn, token.ParameterList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Params)
+
+	if nn.ReturnType != nil {
+		io.WriteString(p.w, ":")
+		p.Print(nn.ReturnType)
+	}
+	p.printFreeFloating(nn, token.ReturnType)
+
+	io.WriteString(p.w, "=>")
+
+	p.printNode(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprBitwiseNot(n ast.Vertex) {
+	nn := n.(*ast.ExprBitwiseNot)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "~")
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprBooleanNot(n ast.Vertex) {
+	nn := n.(*ast.ExprBooleanNot)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "!")
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClassConstFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprClassConstFetch)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Class)
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "::")
+	p.Print(nn.ConstantName)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClone(n ast.Vertex) {
+	nn := n.(*ast.ExprClone)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "clone")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClosureUse(n ast.Vertex) {
+	nn := n.(*ast.ExprClosureUse)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "use")
+	p.printFreeFloating(nn, token.Use)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Uses)
+	p.printFreeFloating(nn, token.LexicalVarList)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClosure(n ast.Vertex) {
+	nn := n.(*ast.ExprClosure)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Static {
+		io.WriteString(p.w, "static")
+	}
+	p.printFreeFloating(nn, token.Static)
+	if nn.Static && n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	io.WriteString(p.w, "function")
+	p.printFreeFloating(nn, token.Function)
+
+	if nn.ReturnsRef {
+		io.WriteString(p.w, "&")
+	}
+	p.printFreeFloating(nn, token.Ampersand)
+
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Params)
+	p.printFreeFloating(nn, token.ParameterList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Params)
+
+	if nn.ClosureUse != nil {
+		p.Print(nn.ClosureUse)
+	}
+	p.printFreeFloating(nn, token.LexicalVars)
+
+	if nn.ReturnType != nil {
+		io.WriteString(p.w, ":")
+		p.Print(nn.ReturnType)
+	}
+	p.printFreeFloating(nn, token.ReturnType)
+
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprConstFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprConstFetch)
+	p.printFreeFloating(nn, token.Start)
+	p.Print(nn.Const)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprEmpty(n ast.Vertex) {
+	nn := n.(*ast.ExprEmpty)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "empty")
+	p.printFreeFloating(nn, token.Empty)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprErrorSuppress(n ast.Vertex) {
+	nn := n.(*ast.ExprErrorSuppress)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "@")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprEval(n ast.Vertex) {
+	nn := n.(*ast.ExprEval)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "eval")
+	p.printFreeFloating(nn, token.Eval)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprExit(n ast.Vertex) {
+	nn := n.(*ast.ExprExit)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Die {
+		io.WriteString(p.w, "die")
+	} else {
+		io.WriteString(p.w, "exit")
+	}
+	p.printFreeFloating(nn, token.Exit)
+
+	if nn.Expr != nil && nn.Expr.GetNode().Tokens.IsEmpty() && nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprFunctionCall(n ast.Vertex) {
+	nn := n.(*ast.ExprFunctionCall)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Function)
+
+	p.printFreeFloating(nn.ArgumentList, token.Start)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.ArgumentList.Arguments)
+	p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn.ArgumentList, token.End)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprInclude(n ast.Vertex) {
+	nn := n.(*ast.ExprInclude)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "include")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprIncludeOnce(n ast.Vertex) {
+	nn := n.(*ast.ExprIncludeOnce)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "include_once")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprInstanceOf(n ast.Vertex) {
+	nn := n.(*ast.ExprInstanceOf)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	io.WriteString(p.w, "instanceof")
+
+	if nn.Class.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Class)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprIsset(n ast.Vertex) {
+	nn := n.(*ast.ExprIsset)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "isset")
+	p.printFreeFloating(nn, token.Isset)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Vars)
+	p.printFreeFloating(nn, token.VarList)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprList(n ast.Vertex) {
+	nn := n.(*ast.ExprList)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "list")
+	p.printFreeFloating(nn, token.List)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Items)
+	p.printFreeFloating(nn, token.ArrayPairList)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprMethodCall(n ast.Vertex) {
+	nn := n.(*ast.ExprMethodCall)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "->")
+	p.Print(nn.Method)
+
+	p.printFreeFloating(nn.ArgumentList, token.Start)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.ArgumentList.Arguments)
+	p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn.ArgumentList, token.End)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprNew(n ast.Vertex) {
+	nn := n.(*ast.ExprNew)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "new")
+	if nn.Class.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Class)
+
+	if nn.ArgumentList != nil {
+		p.printFreeFloating(nn.ArgumentList, token.Start)
+		io.WriteString(p.w, "(")
+		p.joinPrint(",", nn.ArgumentList.Arguments)
+		p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+		io.WriteString(p.w, ")")
+		p.printFreeFloating(nn.ArgumentList, token.End)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPostDec(n ast.Vertex) {
+	nn := n.(*ast.ExprPostDec)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "--")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPostInc(n ast.Vertex) {
+	nn := n.(*ast.ExprPostInc)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "++")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPreDec(n ast.Vertex) {
+	nn := n.(*ast.ExprPreDec)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "--")
+	p.Print(nn.Var)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPreInc(n ast.Vertex) {
+	nn := n.(*ast.ExprPreInc)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "++")
+	p.Print(nn.Var)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPrint(n ast.Vertex) {
+	nn := n.(*ast.ExprPrint)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "print")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPropertyFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprPropertyFetch)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, "->")
+	p.Print(nn.Property)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprReference(n ast.Vertex) {
+	nn := n.(*ast.ExprReference)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "&")
+	p.Print(nn.Var)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprRequire(n ast.Vertex) {
+	nn := n.(*ast.ExprRequire)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "require")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprRequireOnce(n ast.Vertex) {
+	nn := n.(*ast.ExprRequireOnce)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "require_once")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprShellExec(n ast.Vertex) {
+	nn := n.(*ast.ExprShellExec)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "`")
+	p.joinPrint("", nn.Parts)
+	io.WriteString(p.w, "`")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprShortArray(n ast.Vertex) {
+	nn := n.(*ast.ExprShortArray)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "[")
+	p.joinPrint(",", nn.Items)
+	p.printFreeFloating(nn, token.ArrayPairList)
+	io.WriteString(p.w, "]")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprShortList(n ast.Vertex) {
+	nn := n.(*ast.ExprShortList)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "[")
+	p.joinPrint(",", nn.Items)
+	p.printFreeFloating(nn, token.ArrayPairList)
+	io.WriteString(p.w, "]")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprStaticCall(n ast.Vertex) {
+	nn := n.(*ast.ExprStaticCall)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Class)
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "::")
+	p.Print(nn.Call)
+
+	p.printFreeFloating(nn.ArgumentList, token.Start)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.ArgumentList.Arguments)
+	p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn.ArgumentList, token.End)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprStaticPropertyFetch(n ast.Vertex) {
+	nn := n.(*ast.ExprStaticPropertyFetch)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Class)
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "::")
+	p.Print(nn.Property)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprTernary(n ast.Vertex) {
+	nn := n.(*ast.ExprTernary)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Condition)
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, "?")
+
+	if nn.IfTrue != nil {
+		p.Print(nn.IfTrue)
+	}
+	p.printFreeFloating(nn, token.True)
+
+	io.WriteString(p.w, ":")
+	p.Print(nn.IfFalse)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprUnaryMinus(n ast.Vertex) {
+	nn := n.(*ast.ExprUnaryMinus)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "-")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprUnaryPlus(n ast.Vertex) {
+	nn := n.(*ast.ExprUnaryPlus)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "+")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprVariable(n ast.Vertex) {
+	nn := n.(*ast.ExprVariable)
+	p.printFreeFloating(nn, token.Start)
+
+	p.printFreeFloating(nn, token.Dollar)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "$")
+	}
+
+	p.Print(nn.VarName)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprVariableWithoutLeadingDollar(n ast.Vertex) {
+	nn := n.(*ast.ExprVariable)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.VarName)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprYieldFrom(n ast.Vertex) {
+	nn := n.(*ast.ExprYieldFrom)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "yield from")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprYield(n ast.Vertex) {
+	nn := n.(*ast.ExprYield)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "yield")
+
+	if nn.Key != nil {
+		if nn.Key.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Key)
+		p.printFreeFloating(nn, token.Expr)
+		io.WriteString(p.w, "=>")
+	} else {
+		if nn.Value.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.Print(nn.Value)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+// smtm
+
+func (p *Printer) printStmtAltElseIf(n ast.Vertex) {
+	nn := n.(*ast.StmtAltElseIf)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "elseif")
+	p.printFreeFloating(nn, token.ElseIf)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, ":")
+
+	if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
+		p.printNodes(s)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltElse(n ast.Vertex) {
+	nn := n.(*ast.StmtAltElse)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "else")
+	p.printFreeFloating(nn, token.Else)
+	io.WriteString(p.w, ":")
+
+	if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
+		p.printNodes(s)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltFor(n ast.Vertex) {
+	nn := n.(*ast.StmtAltFor)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "for")
+	p.printFreeFloating(nn, token.For)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Init)
+	p.printFreeFloating(nn, token.InitExpr)
+	io.WriteString(p.w, ";")
+	p.joinPrint(",", nn.Cond)
+	p.printFreeFloating(nn, token.CondExpr)
+	io.WriteString(p.w, ";")
+	p.joinPrint(",", nn.Loop)
+	p.printFreeFloating(nn, token.IncExpr)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, ":")
+
+	s := nn.Stmt.(*ast.StmtStmtList)
+	p.printNodes(s.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+
+	io.WriteString(p.w, "endfor")
+	p.printFreeFloating(nn, token.AltEnd)
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltForeach(n ast.Vertex) {
+	nn := n.(*ast.StmtAltForeach)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "foreach")
+	p.printFreeFloating(nn, token.Foreach)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	io.WriteString(p.w, "as")
+
+	if nn.Key != nil {
+		if nn.Key.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Key)
+		p.printFreeFloating(nn, token.Key)
+		io.WriteString(p.w, "=>")
+	} else {
+		if nn.Var.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+
+	io.WriteString(p.w, ":")
+	s := nn.Stmt.(*ast.StmtStmtList)
+	p.printNodes(s.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+
+	io.WriteString(p.w, "endforeach")
+	p.printFreeFloating(nn, token.AltEnd)
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltIf(n ast.Vertex) {
+	nn := n.(*ast.StmtAltIf)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "if")
+	p.printFreeFloating(nn, token.If)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, ":")
+
+	s := nn.Stmt.(*ast.StmtStmtList)
+	p.printNodes(s.Stmts)
+
+	for _, elseif := range nn.ElseIf {
+		p.Print(elseif)
+	}
+
+	if nn.Else != nil {
+		p.Print(nn.Else)
+	}
+
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "endif")
+	p.printFreeFloating(nn, token.AltEnd)
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltSwitch(n ast.Vertex) {
+	nn := n.(*ast.StmtAltSwitch)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "switch")
+	p.printFreeFloating(nn, token.Switch)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, ":")
+
+	p.printFreeFloating(nn.CaseList, token.Start)
+	p.printFreeFloating(nn.CaseList, token.CaseListStart)
+	p.printNodes(nn.CaseList.Cases)
+	p.printFreeFloating(nn.CaseList, token.CaseListEnd)
+	p.printFreeFloating(nn.CaseList, token.End)
+
+	io.WriteString(p.w, "endswitch")
+	p.printFreeFloating(nn, token.AltEnd)
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltWhile(n ast.Vertex) {
+	nn := n.(*ast.StmtAltWhile)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "while")
+	p.printFreeFloating(nn, token.While)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, ":")
+
+	s := nn.Stmt.(*ast.StmtStmtList)
+	p.printNodes(s.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+
+	io.WriteString(p.w, "endwhile")
+	p.printFreeFloating(nn, token.AltEnd)
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtBreak(n ast.Vertex) {
+	nn := n.(*ast.StmtBreak)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "break")
+	if nn.Expr != nil {
+		if nn.Expr.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Expr)
+	}
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtCase(n ast.Vertex) {
+	nn := n.(*ast.StmtCase)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "case")
+	if nn.Cond.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	p.printFreeFloating(nn, token.CaseSeparator)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ":")
+	}
+
+	if len(nn.Stmts) > 0 {
+		p.printNodes(nn.Stmts)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtCatch(n ast.Vertex) {
+	nn := n.(*ast.StmtCatch)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "catch")
+	p.printFreeFloating(nn, token.Catch)
+	io.WriteString(p.w, "(")
+	p.joinPrint("|", nn.Types)
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtClassMethod(n ast.Vertex) {
+	nn := n.(*ast.StmtClassMethod)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Modifiers != nil {
+		for k, m := range nn.Modifiers {
+			if k > 0 && m.GetNode().Tokens.IsEmpty() {
+				io.WriteString(p.w, " ")
+			}
+			p.Print(m)
+		}
+
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+	p.printFreeFloating(nn, token.ModifierList)
+	io.WriteString(p.w, "function")
+	p.printFreeFloating(nn, token.Function)
+
+	if nn.ReturnsRef {
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		io.WriteString(p.w, "&")
+		p.printFreeFloating(nn, token.Ampersand)
+	} else {
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.Print(nn.MethodName)
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Params)
+	p.printFreeFloating(nn, token.ParameterList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Params)
+
+	if nn.ReturnType != nil {
+		io.WriteString(p.w, ":")
+		p.Print(nn.ReturnType)
+	}
+
+	p.Print(nn.Stmt)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtClass(n ast.Vertex) {
+	nn := n.(*ast.StmtClass)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Modifiers != nil {
+		for k, m := range nn.Modifiers {
+			if k > 0 && m.GetNode().Tokens.IsEmpty() {
+				io.WriteString(p.w, " ")
+			}
+			p.Print(m)
+		}
+
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+	p.printFreeFloating(nn, token.ModifierList)
+	io.WriteString(p.w, "class")
+	p.printFreeFloating(nn, token.Class)
+
+	if nn.ClassName != nil {
+		if nn.ClassName.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.ClassName)
+	}
+
+	if nn.ArgumentList != nil {
+		p.printFreeFloating(nn.ArgumentList, token.Start)
+		io.WriteString(p.w, "(")
+		p.joinPrint(",", nn.ArgumentList.Arguments)
+		p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+		io.WriteString(p.w, ")")
+		p.printFreeFloating(nn.ArgumentList, token.End)
+	}
+
+	if nn.Extends != nil {
+		p.printFreeFloating(nn.Extends, token.Start)
+		if nn.Extends.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		io.WriteString(p.w, "extends")
+		if nn.Extends.ClassName.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Extends.ClassName)
+	}
+
+	if nn.Implements != nil {
+		p.printFreeFloating(nn.Implements, token.Start)
+		if nn.Implements.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		io.WriteString(p.w, "implements")
+		if nn.Implements.InterfaceNames[0].GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.joinPrint(",", nn.Implements.InterfaceNames)
+	}
+
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtClassConstList(n ast.Vertex) {
+	nn := n.(*ast.StmtClassConstList)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Modifiers != nil {
+		for k, m := range nn.Modifiers {
+			if k > 0 && m.GetNode().Tokens.IsEmpty() {
+				io.WriteString(p.w, " ")
+			}
+			p.Print(m)
+		}
+
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+	p.printFreeFloating(nn, token.ModifierList)
+	io.WriteString(p.w, "const")
+
+	if nn.Consts[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.joinPrint(",", nn.Consts)
+	p.printFreeFloating(nn, token.ConstList)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtConstList(n ast.Vertex) {
+	nn := n.(*ast.StmtConstList)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "const")
+
+	if nn.Consts[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.joinPrint(",", nn.Consts)
+	p.printFreeFloating(nn, token.Stmts)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtConstant(n ast.Vertex) {
+	nn := n.(*ast.StmtConstant)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.ConstantName)
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "=")
+	p.Print(nn.Expr)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtContinue(n ast.Vertex) {
+	nn := n.(*ast.StmtContinue)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "continue")
+
+	if nn.Expr != nil {
+		if nn.Expr.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Expr)
+	}
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtDeclare(n ast.Vertex) {
+	nn := n.(*ast.StmtDeclare)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "declare")
+	p.printFreeFloating(nn, token.Declare)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Consts)
+	p.printFreeFloating(nn, token.ConstList)
+	io.WriteString(p.w, ")")
+
+	if nn.Alt {
+		p.printFreeFloating(nn, token.Cond)
+		io.WriteString(p.w, ":")
+
+		s := nn.Stmt.(*ast.StmtStmtList)
+		p.printNodes(s.Stmts)
+		p.printFreeFloating(nn, token.Stmts)
+
+		io.WriteString(p.w, "enddeclare")
+		p.printFreeFloating(nn, token.AltEnd)
+
+		p.printFreeFloating(nn, token.SemiColon)
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, ";")
+		}
+	} else {
+		p.Print(nn.Stmt)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtDefault(n ast.Vertex) {
+	nn := n.(*ast.StmtDefault)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "default")
+	p.printFreeFloating(nn, token.Default)
+	p.printFreeFloating(nn, token.CaseSeparator)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ":")
+	}
+
+	if len(nn.Stmts) > 0 {
+		p.printNodes(nn.Stmts)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtDo(n ast.Vertex) {
+	nn := n.(*ast.StmtDo)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "do")
+
+	if _, ok := nn.Stmt.(*ast.StmtStmtList); !ok {
+		if nn.Stmt.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.Print(nn.Stmt)
+	p.printFreeFloating(nn, token.Stmts)
+
+	io.WriteString(p.w, "while")
+	p.printFreeFloating(nn, token.While)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Cond)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtEcho(n ast.Vertex) {
+	nn := n.(*ast.StmtEcho)
+
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "echo")
+	}
+	if nn.Exprs[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	p.printFreeFloating(nn, token.Start)
+	p.printFreeFloating(nn, token.Echo)
+
+	p.joinPrint(",", nn.Exprs)
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtElseif(n ast.Vertex) {
+	nn := n.(*ast.StmtElseIf)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "elseif")
+	p.printFreeFloating(nn, token.ElseIf)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+
+	p.Print(nn.Stmt)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtElse(n ast.Vertex) {
+	nn := n.(*ast.StmtElse)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "else")
+
+	if _, ok := nn.Stmt.(*ast.StmtStmtList); !ok {
+		if nn.Stmt.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.Print(nn.Stmt)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtExpression(n ast.Vertex) {
+	nn := n.(*ast.StmtExpression)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtFinally(n ast.Vertex) {
+	nn := n.(*ast.StmtFinally)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "finally")
+	p.printFreeFloating(nn, token.Finally)
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtFor(n ast.Vertex) {
+	nn := n.(*ast.StmtFor)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "for")
+	p.printFreeFloating(nn, token.For)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Init)
+	p.printFreeFloating(nn, token.InitExpr)
+	io.WriteString(p.w, ";")
+	p.joinPrint(",", nn.Cond)
+	p.printFreeFloating(nn, token.CondExpr)
+	io.WriteString(p.w, ";")
+	p.joinPrint(",", nn.Loop)
+	p.printFreeFloating(nn, token.IncExpr)
+	io.WriteString(p.w, ")")
+
+	p.Print(nn.Stmt)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtForeach(n ast.Vertex) {
+	nn := n.(*ast.StmtForeach)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "foreach")
+	p.printFreeFloating(nn, token.Foreach)
+	io.WriteString(p.w, "(")
+
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	io.WriteString(p.w, "as")
+
+	if nn.Key != nil {
+		if nn.Key.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Key)
+		p.printFreeFloating(nn, token.Key)
+		io.WriteString(p.w, "=>")
+	} else {
+		if nn.Var.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+	p.Print(nn.Var)
+	p.printFreeFloating(nn, token.Var)
+
+	io.WriteString(p.w, ")")
+
+	p.Print(nn.Stmt)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtFunction(n ast.Vertex) {
+	nn := n.(*ast.StmtFunction)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "function")
+	p.printFreeFloating(nn, token.Function)
+
+	if nn.ReturnsRef {
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		io.WriteString(p.w, "&")
+	} else {
+		if nn.FunctionName.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.Print(nn.FunctionName)
+	p.printFreeFloating(nn, token.Name)
+
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Params)
+	p.printFreeFloating(nn, token.ParamList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.Params)
+
+	if nn.ReturnType != nil {
+		io.WriteString(p.w, ":")
+		p.Print(nn.ReturnType)
+	}
+	p.printFreeFloating(nn, token.ReturnType)
+
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtGlobal(n ast.Vertex) {
+	nn := n.(*ast.StmtGlobal)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "global")
+	p.joinPrint(",", nn.Vars)
+	p.printFreeFloating(nn, token.VarList)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtGoto(n ast.Vertex) {
+	nn := n.(*ast.StmtGoto)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "goto")
+	if nn.Label.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Label)
+	p.printFreeFloating(nn, token.Label)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtGroupUse(n ast.Vertex) {
+	nn := n.(*ast.StmtGroupUse)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "use")
+	p.printFreeFloating(nn, token.Use)
+
+	if nn.UseType != nil {
+		if nn.UseType.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.UseType)
+	}
+
+	if nn.Prefix.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Prefix)
+	io.WriteString(p.w, "\\")
+	p.printFreeFloating(nn, token.Slash)
+
+	io.WriteString(p.w, "{")
+	p.joinPrint(",", nn.UseList)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+	p.printFreeFloating(nn, token.UseDeclarationList)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtHaltCompiler(n ast.Vertex) {
+	nn := n.(*ast.StmtHaltCompiler)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "__halt_compiler")
+	p.printFreeFloating(nn, token.HaltCompiller)
+	io.WriteString(p.w, "(")
+	p.printFreeFloating(nn, token.OpenParenthesisToken)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.CloseParenthesisToken)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtIf(n ast.Vertex) {
+	nn := n.(*ast.StmtIf)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "if")
+	p.printFreeFloating(n, token.If)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(n, token.Expr)
+	io.WriteString(p.w, ")")
+
+	p.Print(nn.Stmt)
+
+	if nn.ElseIf != nil {
+		p.printNodes(nn.ElseIf)
+	}
+
+	if nn.Else != nil {
+		p.Print(nn.Else)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtInlineHTML(n ast.Vertex) {
+	nn := n.(*ast.StmtInlineHtml)
+	p.printFreeFloating(nn, token.Start)
+
+	if p.s == PhpState && nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, "?>")
+	}
+	p.SetState(HtmlState)
+
+	io.WriteString(p.w, string(nn.Value))
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtInterface(n ast.Vertex) {
+	nn := n.(*ast.StmtInterface)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "interface")
+
+	if nn.InterfaceName.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	p.Print(nn.InterfaceName)
+
+	if nn.Extends != nil {
+		p.printFreeFloating(nn.Extends, token.Start)
+		if nn.Extends.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		io.WriteString(p.w, "extends")
+		if nn.Extends.InterfaceNames[0].GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.joinPrint(",", nn.Extends.InterfaceNames)
+	}
+
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtLabel(n ast.Vertex) {
+	nn := n.(*ast.StmtLabel)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.LabelName)
+	p.printFreeFloating(nn, token.Label)
+
+	io.WriteString(p.w, ":")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtNamespace(n ast.Vertex) {
+	nn := n.(*ast.StmtNamespace)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "namespace")
+
+	if nn.NamespaceName != nil {
+		if nn.NamespaceName.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.NamespaceName)
+	}
+
+	if nn.Stmts != nil {
+		p.printFreeFloating(nn, token.Namespace)
+		io.WriteString(p.w, "{")
+		p.printNodes(nn.Stmts)
+		p.printFreeFloating(nn, token.Stmts)
+		io.WriteString(p.w, "}")
+	} else {
+		p.printFreeFloating(nn, token.SemiColon)
+		if nn.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, ";")
+		}
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtNop(n ast.Vertex) {
+	p.printFreeFloating(n, token.Start)
+	p.printFreeFloating(n, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+	p.printFreeFloating(n, token.End)
+}
+
+func (p *Printer) printStmtPropertyList(n ast.Vertex) {
+	nn := n.(*ast.StmtPropertyList)
+	p.printFreeFloating(nn, token.Start)
+
+	for k, m := range nn.Modifiers {
+		if k > 0 && m.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(m)
+	}
+
+	if nn.Type != nil && nn.Type.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	p.Print(nn.Type)
+
+	if nn.Properties[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	p.joinPrint(",", nn.Properties)
+	p.printFreeFloating(n, token.PropertyList)
+
+	p.printFreeFloating(n, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtProperty(n ast.Vertex) {
+	nn := n.(*ast.StmtProperty)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Var)
+
+	if nn.Expr != nil {
+		p.printFreeFloating(nn, token.Var)
+		io.WriteString(p.w, "=")
+		p.Print(nn.Expr)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtReturn(n ast.Vertex) {
+	nn := n.(*ast.StmtReturn)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "return")
+	if nn.Expr != nil && nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtStaticVar(n ast.Vertex) {
+	nn := n.(*ast.StmtStaticVar)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Var)
+
+	if nn.Expr != nil {
+		p.printFreeFloating(nn, token.Var)
+		io.WriteString(p.w, "=")
+		p.Print(nn.Expr)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtStatic(n ast.Vertex) {
+	nn := n.(*ast.StmtStatic)
+	p.printFreeFloating(nn, token.Start)
+	io.WriteString(p.w, "static")
+
+	p.joinPrint(",", nn.Vars)
+	p.printFreeFloating(nn, token.VarList)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtStmtList(n ast.Vertex) {
+	nn := n.(*ast.StmtStmtList)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtSwitch(n ast.Vertex) {
+	nn := n.(*ast.StmtSwitch)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "switch")
+	p.printFreeFloating(nn, token.Switch)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+
+	p.printFreeFloating(nn.CaseList, token.Start)
+	io.WriteString(p.w, "{")
+	p.printFreeFloating(nn.CaseList, token.CaseListStart)
+	p.printNodes(nn.CaseList.Cases)
+	p.printFreeFloating(nn.CaseList, token.CaseListEnd)
+	io.WriteString(p.w, "}")
+	p.printFreeFloating(nn.CaseList, token.End)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtThrow(n ast.Vertex) {
+	nn := n.(*ast.StmtThrow)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "throw")
+	if nn.Expr.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.Expr)
+	p.printFreeFloating(nn, token.Expr)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitAdaptationList(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitAdaptationList)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Adaptations)
+	p.printFreeFloating(nn, token.AdaptationList)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitMethodRef(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitMethodRef)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.Trait != nil {
+		p.Print(nn.Trait)
+		p.printFreeFloating(nn, token.Name)
+		io.WriteString(p.w, "::")
+	}
+
+	p.Print(nn.Method)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitUseAlias(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitUseAlias)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Ref)
+	p.printFreeFloating(nn, token.Ref)
+
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	io.WriteString(p.w, "as")
+
+	if nn.Modifier != nil {
+		if nn.Modifier.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Modifier)
+	}
+
+	if nn.Alias != nil {
+		if nn.Alias.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Alias)
+	}
+	p.printFreeFloating(nn, token.Alias)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitUsePrecedence(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitUsePrecedence)
+	p.printFreeFloating(nn, token.Start)
+
+	p.Print(nn.Ref)
+	p.printFreeFloating(nn, token.Ref)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+
+	io.WriteString(p.w, "insteadof")
+	if nn.Insteadof[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.joinPrint(",", nn.Insteadof)
+	p.printFreeFloating(nn, token.NameList)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitUse(n ast.Vertex) {
+	nn := n.(*ast.StmtTraitUse)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "use")
+	if nn.Traits[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.joinPrint(",", nn.Traits)
+
+	p.Print(nn.TraitAdaptationList)
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTrait(n ast.Vertex) {
+	nn := n.(*ast.StmtTrait)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "trait")
+	if nn.TraitName.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.Print(nn.TraitName)
+
+	p.printFreeFloating(nn, token.Name)
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTry(n ast.Vertex) {
+	nn := n.(*ast.StmtTry)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "try")
+	p.printFreeFloating(nn, token.Try)
+	io.WriteString(p.w, "{")
+	p.printNodes(nn.Stmts)
+	p.printFreeFloating(nn, token.Stmts)
+	io.WriteString(p.w, "}")
+
+	if nn.Catches != nil {
+		p.printNodes(nn.Catches)
+	}
+
+	if nn.Finally != nil {
+		p.Print(nn.Finally)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtUnset(n ast.Vertex) {
+	nn := n.(*ast.StmtUnset)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "unset")
+	p.printFreeFloating(nn, token.Unset)
+	io.WriteString(p.w, "(")
+	p.joinPrint(",", nn.Vars)
+	p.printFreeFloating(nn, token.VarList)
+	io.WriteString(p.w, ")")
+	p.printFreeFloating(nn, token.CloseParenthesisToken)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if n.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtUseList(n ast.Vertex) {
+	nn := n.(*ast.StmtUseList)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "use")
+
+	if nn.UseType != nil {
+		if nn.UseType.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.UseType)
+	}
+
+	if nn.Uses[0].GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, " ")
+	}
+	p.joinPrint(",", nn.Uses)
+	p.printFreeFloating(nn, token.UseDeclarationList)
+
+	p.printFreeFloating(nn, token.SemiColon)
+	if nn.GetNode().Tokens.IsEmpty() {
+		io.WriteString(p.w, ";")
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtUse(n ast.Vertex) {
+	nn := n.(*ast.StmtUse)
+	p.printFreeFloating(nn, token.Start)
+
+	if nn.UseType != nil {
+		p.Print(nn.UseType)
+		if nn.UseType.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+	}
+
+	p.printFreeFloating(nn, token.Slash)
+
+	p.Print(nn.Use)
+
+	if nn.Alias != nil {
+		if nn.Alias.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		io.WriteString(p.w, "as")
+		if nn.Alias.GetNode().Tokens.IsEmpty() {
+			io.WriteString(p.w, " ")
+		}
+		p.Print(nn.Alias)
+	}
+
+	p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtWhile(n ast.Vertex) {
+	nn := n.(*ast.StmtWhile)
+	p.printFreeFloating(nn, token.Start)
+
+	io.WriteString(p.w, "while")
+	p.printFreeFloating(nn, token.While)
+	io.WriteString(p.w, "(")
+	p.Print(nn.Cond)
+	p.printFreeFloating(nn, token.Expr)
+	io.WriteString(p.w, ")")
+
+	p.Print(nn.Stmt)
+
+	p.printFreeFloating(nn, token.End)
+}
diff --git a/printer/printer_parsed_php5_test.go b/pkg/printer/printer_parsed_php5_test.go
similarity index 99%
rename from printer/printer_parsed_php5_test.go
rename to pkg/printer/printer_parsed_php5_test.go
index 660987a..14868ac 100644
--- a/printer/printer_parsed_php5_test.go
+++ b/pkg/printer/printer_parsed_php5_test.go
@@ -2,22 +2,22 @@ package printer_test
 
 import (
 	"bytes"
+	"github.com/z7zmey/php-parser/pkg/ast"
 	"testing"
 
-	"github.com/z7zmey/php-parser/node"
-	"github.com/z7zmey/php-parser/php5"
-	"github.com/z7zmey/php-parser/printer"
+	"github.com/z7zmey/php-parser/internal/php5"
+	"github.com/z7zmey/php-parser/pkg/printer"
 )
 
-func parsePhp5(src string) node.Node {
+func parsePhp5(src string) ast.Vertex {
 	php5parser := php5.NewParser([]byte(src), "5.6")
-	php5parser.WithFreeFloating()
+	php5parser.WithTokens()
 	php5parser.Parse()
 
 	return php5parser.GetRootNode()
 }
 
-func printPhp5(n node.Node) string {
+func printPhp5(n ast.Vertex) string {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
diff --git a/printer/printer_parsed_php7_test.go b/pkg/printer/printer_parsed_php7_test.go
similarity index 98%
rename from printer/printer_parsed_php7_test.go
rename to pkg/printer/printer_parsed_php7_test.go
index d50dc59..971219f 100644
--- a/printer/printer_parsed_php7_test.go
+++ b/pkg/printer/printer_parsed_php7_test.go
@@ -2,14 +2,12 @@ package printer_test
 
 import (
 	"bytes"
+	"github.com/z7zmey/php-parser/pkg/ast"
 	"os"
 	"testing"
 
-	"github.com/z7zmey/php-parser/node"
-	"github.com/z7zmey/php-parser/node/name"
-	"github.com/z7zmey/php-parser/node/stmt"
-	"github.com/z7zmey/php-parser/php7"
-	"github.com/z7zmey/php-parser/printer"
+	"github.com/z7zmey/php-parser/internal/php7"
+	"github.com/z7zmey/php-parser/pkg/printer"
 )
 
 func ExamplePrinter() {
@@ -30,15 +28,15 @@ abstract class Bar extends Baz
 	// parse
 
 	php7parser := php7.NewParser([]byte(src), "7.4")
-	php7parser.WithFreeFloating()
+	php7parser.WithTokens()
 	php7parser.Parse()
 
 	rootNode := php7parser.GetRootNode()
 
 	// change namespace
 
-	parts := &rootNode.(*node.Root).Stmts[0].(*stmt.Namespace).NamespaceName.(*name.Name).Parts
-	*parts = append(*parts, &name.NamePart{Value: "Quuz"})
+	parts := &rootNode.(*ast.Root).Stmts[0].(*ast.StmtNamespace).NamespaceName.(*ast.NameName).Parts
+	*parts = append(*parts, &ast.NameNamePart{Value: []byte("Quuz")})
 
 	// print
 
@@ -60,15 +58,15 @@ abstract class Bar extends Baz
 	// }
 }
 
-func parse(src string) node.Node {
+func parse(src string) ast.Vertex {
 	php7parser := php7.NewParser([]byte(src), "7.4")
-	php7parser.WithFreeFloating()
+	php7parser.WithTokens()
 	php7parser.Parse()
 
 	return php7parser.GetRootNode()
 }
 
-func print(n node.Node) string {
+func print(n ast.Vertex) string {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
diff --git a/printer/printer_test.go b/pkg/printer/printer_test.go
similarity index 54%
rename from printer/printer_test.go
rename to pkg/printer/printer_test.go
index 331de66..a2df1a1 100644
--- a/printer/printer_test.go
+++ b/pkg/printer/printer_test.go
@@ -2,56 +2,49 @@ package printer_test
 
 import (
 	"bytes"
+	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/token"
 	"testing"
 
-	"github.com/z7zmey/php-parser/freefloating"
-	"github.com/z7zmey/php-parser/node"
-	"github.com/z7zmey/php-parser/node/expr"
-	"github.com/z7zmey/php-parser/node/expr/assign"
-	"github.com/z7zmey/php-parser/node/expr/binary"
-	"github.com/z7zmey/php-parser/node/expr/cast"
-	"github.com/z7zmey/php-parser/node/name"
-	"github.com/z7zmey/php-parser/node/scalar"
-	"github.com/z7zmey/php-parser/node/stmt"
-	"github.com/z7zmey/php-parser/printer"
+	"github.com/z7zmey/php-parser/pkg/printer"
 )
 
 func TestPrinterPrintFile(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Root{
-		Stmts: []node.Node{
-			&stmt.Namespace{
-				NamespaceName: &name.Name{
-					Parts: []node.Node{
-						&name.NamePart{Value: "Foo"},
+	p.Print(&ast.Root{
+		Stmts: []ast.Vertex{
+			&ast.StmtNamespace{
+				NamespaceName: &ast.NameName{
+					Parts: []ast.Vertex{
+						&ast.NameNamePart{Value: []byte("Foo")},
 					},
 				},
 			},
-			&stmt.Class{
-				Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
-				ClassName: &name.Name{
-					Parts: []node.Node{
-						&name.NamePart{Value: "Bar"},
+			&ast.StmtClass{
+				Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+				ClassName: &ast.NameName{
+					Parts: []ast.Vertex{
+						&ast.NameNamePart{Value: []byte("Bar")},
 					},
 				},
-				Extends: &stmt.ClassExtends{
-					ClassName: &name.Name{
-						Parts: []node.Node{
-							&name.NamePart{Value: "Baz"},
+				Extends: &ast.StmtClassExtends{
+					ClassName: &ast.NameName{
+						Parts: []ast.Vertex{
+							&ast.NameNamePart{Value: []byte("Baz")},
 						},
 					},
 				},
-				Stmts: []node.Node{
-					&stmt.ClassMethod{
-						Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
-						MethodName: &node.Identifier{Value: "greet"},
-						Stmt: &stmt.StmtList{
-							Stmts: []node.Node{
-								&stmt.Echo{
-									Exprs: []node.Node{
-										&scalar.String{Value: "'Hello world'"},
+				Stmts: []ast.Vertex{
+					&ast.StmtClassMethod{
+						Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+						MethodName: &ast.Identifier{Value: []byte("greet")},
+						Stmt: &ast.StmtStmtList{
+							Stmts: []ast.Vertex{
+								&ast.StmtEcho{
+									Exprs: []ast.Vertex{
+										&ast.ScalarString{Value: []byte("'Hello world'")},
 									},
 								},
 							},
@@ -74,37 +67,41 @@ func TestPrinterPrintFileInlineHtml(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Root{
-		Stmts: []node.Node{
-			&stmt.InlineHtml{Value: "<div>HTML</div>"},
-			&stmt.Expression{
-				Expr: &expr.Variable{
-					FreeFloating: freefloating.Collection{
-						freefloating.Start: []freefloating.String{
-							{
-								StringType: freefloating.TokenType,
-								Value:      "$",
+	p.Print(&ast.Root{
+		Stmts: []ast.Vertex{
+			&ast.StmtInlineHtml{Value: []byte("<div>HTML</div>")},
+			&ast.StmtExpression{
+				Expr: &ast.ExprVariable{
+					Node: ast.Node{
+						Tokens: token.Collection{
+							token.Start: []token.Token{
+								{
+									ID:    token.ID('$'),
+									Value: []byte("$"),
+								},
 							},
 						},
 					},
-					VarName: &node.Identifier{
-						Value: "a",
+					VarName: &ast.Identifier{
+						Value: []byte("a"),
 					},
 				},
 			},
-			&stmt.InlineHtml{Value: "<div>HTML</div>"},
-			&stmt.Expression{
-				Expr: &expr.Variable{
-					FreeFloating: freefloating.Collection{
-						freefloating.Start: []freefloating.String{
-							{
-								StringType: freefloating.TokenType,
-								Value:      "$",
+			&ast.StmtInlineHtml{Value: []byte("<div>HTML</div>")},
+			&ast.StmtExpression{
+				Expr: &ast.ExprVariable{
+					Node: ast.Node{
+						Tokens: token.Collection{
+							token.Start: []token.Token{
+								{
+									ID:    token.ID('$'),
+									Value: []byte("$"),
+								},
 							},
 						},
 					},
-					VarName: &node.Identifier{
-						Value: "a",
+					VarName: &ast.Identifier{
+						Value: []byte("a"),
 					},
 				},
 			},
@@ -125,8 +122,8 @@ func TestPrinterPrintIdentifier(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	n := &node.Identifier{
-		Value: "test",
+	n := &ast.Identifier{
+		Value: []byte("test"),
 	}
 	p.Print(n)
 
@@ -142,21 +139,21 @@ func TestPrinterPrintParameter(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Parameter{
+	p.Print(&ast.Parameter{
 		ByRef:    false,
 		Variadic: true,
-		VariableType: &name.FullyQualified{
-			Parts: []node.Node{
-				&name.NamePart{
-					Value: "Foo",
+		Type: &ast.NameFullyQualified{
+			Parts: []ast.Vertex{
+				&ast.NameNamePart{
+					Value: []byte("Foo"),
 				},
 			},
 		},
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		DefaultValue: &scalar.String{
-			Value: "'default'",
+		DefaultValue: &ast.ScalarString{
+			Value: []byte("'default'"),
 		},
 	})
 
@@ -172,24 +169,24 @@ func TestPrinterPrintNullable(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Nullable{
-		Expr: &node.Parameter{
+	p.Print(&ast.Nullable{
+		Expr: &ast.Parameter{
 			ByRef:    true,
 			Variadic: false,
-			VariableType: &name.FullyQualified{
-				Parts: []node.Node{
-					&name.NamePart{
-						Value: "Foo",
+			Type: &ast.NameFullyQualified{
+				Parts: []ast.Vertex{
+					&ast.NameNamePart{
+						Value: []byte("Foo"),
 					},
 				},
 			},
-			Variable: &expr.Variable{
-				VarName: &node.Identifier{
-					Value: "var",
+			Var: &ast.ExprVariable{
+				VarName: &ast.Identifier{
+					Value: []byte("var"),
 				},
 			},
-			DefaultValue: &scalar.String{
-				Value: "'default'",
+			DefaultValue: &ast.ScalarString{
+				Value: []byte("'default'"),
 			},
 		},
 	})
@@ -206,12 +203,12 @@ func TestPrinterPrintArgument(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Argument{
+	p.Print(&ast.Argument{
 		IsReference: false,
 		Variadic:    true,
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{
-				Value: "var",
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{
+				Value: []byte("var"),
 			},
 		},
 	})
@@ -227,12 +224,12 @@ func TestPrinterPrintArgumentByRef(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Argument{
+	p.Print(&ast.Argument{
 		IsReference: true,
 		Variadic:    false,
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{
-				Value: "var",
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{
+				Value: []byte("var"),
 			},
 		},
 	})
@@ -251,8 +248,8 @@ func TestPrinterPrintNameNamePart(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&name.NamePart{
-		Value: "foo",
+	p.Print(&ast.NameNamePart{
+		Value: []byte("foo"),
 	})
 
 	expected := "foo"
@@ -267,13 +264,13 @@ func TestPrinterPrintNameName(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&name.Name{
-		Parts: []node.Node{
-			&name.NamePart{
-				Value: "Foo",
+	p.Print(&ast.NameName{
+		Parts: []ast.Vertex{
+			&ast.NameNamePart{
+				Value: []byte("Foo"),
 			},
-			&name.NamePart{
-				Value: "Bar",
+			&ast.NameNamePart{
+				Value: []byte("Bar"),
 			},
 		},
 	})
@@ -290,13 +287,13 @@ func TestPrinterPrintNameFullyQualified(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&name.FullyQualified{
-		Parts: []node.Node{
-			&name.NamePart{
-				Value: "Foo",
+	p.Print(&ast.NameFullyQualified{
+		Parts: []ast.Vertex{
+			&ast.NameNamePart{
+				Value: []byte("Foo"),
 			},
-			&name.NamePart{
-				Value: "Bar",
+			&ast.NameNamePart{
+				Value: []byte("Bar"),
 			},
 		},
 	})
@@ -313,13 +310,13 @@ func TestPrinterPrintNameRelative(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&name.Relative{
-		Parts: []node.Node{
-			&name.NamePart{
-				Value: "Foo",
+	p.Print(&ast.NameRelative{
+		Parts: []ast.Vertex{
+			&ast.NameNamePart{
+				Value: []byte("Foo"),
 			},
-			&name.NamePart{
-				Value: "Bar",
+			&ast.NameNamePart{
+				Value: []byte("Bar"),
 			},
 		},
 	})
@@ -338,8 +335,8 @@ func TestPrinterPrintScalarLNumber(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.Lnumber{
-		Value: "1",
+	p.Print(&ast.ScalarLnumber{
+		Value: []byte("1"),
 	})
 
 	expected := "1"
@@ -354,8 +351,8 @@ func TestPrinterPrintScalarDNumber(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.Dnumber{
-		Value: ".1",
+	p.Print(&ast.ScalarDnumber{
+		Value: []byte(".1"),
 	})
 
 	expected := ".1"
@@ -370,8 +367,8 @@ func TestPrinterPrintScalarString(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.String{
-		Value: "'hello world'",
+	p.Print(&ast.ScalarString{
+		Value: []byte("'hello world'"),
 	})
 
 	expected := `'hello world'`
@@ -386,8 +383,8 @@ func TestPrinterPrintScalarEncapsedStringPart(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.EncapsedStringPart{
-		Value: "hello world",
+	p.Print(&ast.ScalarEncapsedStringPart{
+		Value: []byte("hello world"),
 	})
 
 	expected := `hello world`
@@ -402,13 +399,13 @@ func TestPrinterPrintScalarEncapsed(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.Encapsed{
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello "},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ScalarEncapsed{
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("var")},
 			},
-			&scalar.EncapsedStringPart{Value: " world"},
+			&ast.ScalarEncapsedStringPart{Value: []byte(" world")},
 		},
 	})
 
@@ -424,14 +421,14 @@ func TestPrinterPrintScalarHeredoc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.Heredoc{
-		Label: "<<<LBL\n",
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello "},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ScalarHeredoc{
+		Label: []byte("<<<LBL\n"),
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("var")},
 			},
-			&scalar.EncapsedStringPart{Value: " world\n"},
+			&ast.ScalarEncapsedStringPart{Value: []byte(" world\n")},
 		},
 	})
 
@@ -449,10 +446,10 @@ func TestPrinterPrintScalarNowdoc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.Heredoc{
-		Label: "<<<'LBL'\n",
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello world\n"},
+	p.Print(&ast.ScalarHeredoc{
+		Label: []byte("<<<'LBL'\n"),
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
 		},
 	})
 
@@ -470,8 +467,8 @@ func TestPrinterPrintScalarMagicConstant(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&scalar.MagicConstant{
-		Value: "__DIR__",
+	p.Print(&ast.ScalarMagicConstant{
+		Value: []byte("__DIR__"),
 	})
 
 	if o.String() != `__DIR__` {
@@ -485,12 +482,12 @@ func TestPrinterPrintAssign(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Assign{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssign{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -506,12 +503,12 @@ func TestPrinterPrintReference(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Reference{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignReference{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -527,12 +524,12 @@ func TestPrinterPrintAssignBitwiseAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.BitwiseAnd{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignBitwiseAnd{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -548,12 +545,12 @@ func TestPrinterPrintAssignBitwiseOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.BitwiseOr{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignBitwiseOr{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -569,12 +566,12 @@ func TestPrinterPrintAssignBitwiseXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.BitwiseXor{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignBitwiseXor{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -590,12 +587,12 @@ func TestPrinterPrintAssignCoalesce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Coalesce{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignCoalesce{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -611,12 +608,12 @@ func TestPrinterPrintAssignConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Concat{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignConcat{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -632,12 +629,12 @@ func TestPrinterPrintAssignDiv(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Div{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignDiv{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -653,12 +650,12 @@ func TestPrinterPrintAssignMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Minus{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignMinus{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -674,12 +671,12 @@ func TestPrinterPrintAssignMod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Mod{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignMod{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -695,12 +692,12 @@ func TestPrinterPrintAssignMul(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Mul{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignMul{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -716,12 +713,12 @@ func TestPrinterPrintAssignPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Plus{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignPlus{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -737,12 +734,12 @@ func TestPrinterPrintAssignPow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.Pow{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignPow{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -758,12 +755,12 @@ func TestPrinterPrintAssignShiftLeft(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.ShiftLeft{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignShiftLeft{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -779,12 +776,12 @@ func TestPrinterPrintAssignShiftRight(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&assign.ShiftRight{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprAssignShiftRight{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expression: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -802,12 +799,12 @@ func TestPrinterPrintBinaryBitwiseAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.BitwiseAnd{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryBitwiseAnd{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -823,12 +820,12 @@ func TestPrinterPrintBinaryBitwiseOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.BitwiseOr{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryBitwiseOr{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -844,12 +841,12 @@ func TestPrinterPrintBinaryBitwiseXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.BitwiseXor{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryBitwiseXor{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -865,12 +862,12 @@ func TestPrinterPrintBinaryBooleanAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.BooleanAnd{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryBooleanAnd{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -886,12 +883,12 @@ func TestPrinterPrintBinaryBooleanOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.BooleanOr{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryBooleanOr{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -907,12 +904,12 @@ func TestPrinterPrintBinaryCoalesce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Coalesce{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryCoalesce{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -928,12 +925,12 @@ func TestPrinterPrintBinaryConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Concat{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryConcat{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -949,12 +946,12 @@ func TestPrinterPrintBinaryDiv(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Div{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryDiv{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -970,12 +967,12 @@ func TestPrinterPrintBinaryEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Equal{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryEqual{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -991,12 +988,12 @@ func TestPrinterPrintBinaryGreaterOrEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.GreaterOrEqual{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryGreaterOrEqual{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1012,12 +1009,12 @@ func TestPrinterPrintBinaryGreater(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Greater{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryGreater{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1033,12 +1030,12 @@ func TestPrinterPrintBinaryIdentical(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Identical{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryIdentical{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1054,12 +1051,12 @@ func TestPrinterPrintBinaryLogicalAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.LogicalAnd{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryLogicalAnd{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1075,12 +1072,12 @@ func TestPrinterPrintBinaryLogicalOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.LogicalOr{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryLogicalOr{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1096,12 +1093,12 @@ func TestPrinterPrintBinaryLogicalXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.LogicalXor{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryLogicalXor{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1117,12 +1114,12 @@ func TestPrinterPrintBinaryMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Minus{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryMinus{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1138,12 +1135,12 @@ func TestPrinterPrintBinaryMod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Mod{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryMod{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1159,12 +1156,12 @@ func TestPrinterPrintBinaryMul(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Mul{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryMul{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1180,12 +1177,12 @@ func TestPrinterPrintBinaryNotEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.NotEqual{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryNotEqual{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1201,12 +1198,12 @@ func TestPrinterPrintBinaryNotIdentical(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.NotIdentical{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryNotIdentical{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1222,12 +1219,12 @@ func TestPrinterPrintBinaryPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Plus{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryPlus{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1243,12 +1240,12 @@ func TestPrinterPrintBinaryPow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Pow{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryPow{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1264,12 +1261,12 @@ func TestPrinterPrintBinaryShiftLeft(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.ShiftLeft{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryShiftLeft{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1285,12 +1282,12 @@ func TestPrinterPrintBinaryShiftRight(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.ShiftRight{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinaryShiftRight{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1306,12 +1303,12 @@ func TestPrinterPrintBinarySmallerOrEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.SmallerOrEqual{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinarySmallerOrEqual{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1327,12 +1324,12 @@ func TestPrinterPrintBinarySmaller(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Smaller{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinarySmaller{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1348,12 +1345,12 @@ func TestPrinterPrintBinarySpaceship(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&binary.Spaceship{
-		Left: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprBinarySpaceship{
+		Left: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Right: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		Right: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -1371,9 +1368,9 @@ func TestPrinterPrintArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.Array{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastArray{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1389,9 +1386,9 @@ func TestPrinterPrintBool(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.Bool{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastBool{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1407,9 +1404,9 @@ func TestPrinterPrintDouble(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.Double{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastDouble{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1425,9 +1422,9 @@ func TestPrinterPrintInt(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.Int{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastInt{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1443,9 +1440,9 @@ func TestPrinterPrintObject(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.Object{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastObject{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1461,9 +1458,9 @@ func TestPrinterPrintString(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.String{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastString{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1479,9 +1476,9 @@ func TestPrinterPrintUnset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&cast.Unset{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprCastUnset{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1499,11 +1496,11 @@ func TestPrinterPrintExprArrayDimFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ArrayDimFetch{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprArrayDimFetch{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		Dim: &scalar.Lnumber{Value: "1"},
+		Dim: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `$var[1]`
@@ -1518,10 +1515,10 @@ func TestPrinterPrintExprArrayItemWithKey(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ArrayItem{
-		Key: &scalar.String{Value: "'Hello'"},
-		Val: &expr.Variable{
-			VarName: &node.Identifier{Value: "world"},
+	p.Print(&ast.ExprArrayItem{
+		Key: &ast.ScalarString{Value: []byte("'Hello'")},
+		Val: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("world")},
 		},
 	})
 
@@ -1537,9 +1534,9 @@ func TestPrinterPrintExprArrayItem(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ArrayItem{
-		Val: &expr.Reference{Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "world"},
+	p.Print(&ast.ExprArrayItem{
+		Val: &ast.ExprReference{Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("world")},
 		}},
 	})
 
@@ -1555,10 +1552,10 @@ func TestPrinterPrintExprArrayItemUnpack(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ArrayItem{
+	p.Print(&ast.ExprArrayItem{
 		Unpack: true,
-		Val: &expr.Variable{
-			VarName: &node.Identifier{Value: "world"},
+		Val: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("world")},
 		},
 	})
 
@@ -1574,23 +1571,23 @@ func TestPrinterPrintExprArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Array{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Key: &scalar.String{Value: "'Hello'"},
-				Val: &expr.Variable{
-					VarName: &node.Identifier{Value: "world"},
+	p.Print(&ast.ExprArray{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarString{Value: []byte("'Hello'")},
+				Val: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("world")},
 				},
 			},
-			&expr.ArrayItem{
-				Key: &scalar.Lnumber{Value: "2"},
-				Val: &expr.Reference{Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "var"},
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarLnumber{Value: []byte("2")},
+				Val: &ast.ExprReference{Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("var")},
 				}},
 			},
-			&expr.ArrayItem{
-				Val: &expr.Variable{
-					VarName: &node.Identifier{Value: "var"},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("var")},
 				},
 			},
 		},
@@ -1608,9 +1605,9 @@ func TestPrinterPrintExprBitwiseNot(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.BitwiseNot{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprBitwiseNot{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1626,9 +1623,9 @@ func TestPrinterPrintExprBooleanNot(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.BooleanNot{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprBooleanNot{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1644,12 +1641,12 @@ func TestPrinterPrintExprClassConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ClassConstFetch{
-		Class: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprClassConstFetch{
+		Class: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		ConstantName: &node.Identifier{
-			Value: "CONST",
+		ConstantName: &ast.Identifier{
+			Value: []byte("CONST"),
 		},
 	})
 
@@ -1665,9 +1662,9 @@ func TestPrinterPrintExprClone(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Clone{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprClone{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1683,13 +1680,13 @@ func TestPrinterPrintExprClosureUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ClosureUse{
-		Uses: []node.Node{
-			&expr.Reference{Variable: &expr.Variable{
-				VarName: &node.Identifier{Value: "foo"},
+	p.Print(&ast.ExprClosureUse{
+		Uses: []ast.Vertex{
+			&ast.ExprReference{Var: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("foo")},
 			}},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "bar"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("bar")},
 			},
 		},
 	})
@@ -1706,34 +1703,34 @@ func TestPrinterPrintExprClosure(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Closure{
+	p.Print(&ast.ExprClosure{
 		Static:     true,
 		ReturnsRef: true,
-		Params: []node.Node{
-			&node.Parameter{
+		Params: []ast.Vertex{
+			&ast.Parameter{
 				ByRef:    true,
 				Variadic: false,
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "var"},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("var")},
 				},
 			},
 		},
-		ClosureUse: &expr.ClosureUse{
-			Uses: []node.Node{
-				&expr.Reference{Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+		ClosureUse: &ast.ExprClosureUse{
+			Uses: []ast.Vertex{
+				&ast.ExprReference{Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				}},
-				&expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+				&ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				},
 			},
 		},
-		ReturnType: &name.FullyQualified{
-			Parts: []node.Node{&name.NamePart{Value: "Foo"}},
+		ReturnType: &ast.NameFullyQualified{
+			Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}},
 		},
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
 		},
 	})
@@ -1750,24 +1747,24 @@ func TestPrinterPrintExprArrowFunction(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Expression{
-		Expr: &expr.ArrowFunction{
+	p.Print(&ast.StmtExpression{
+		Expr: &ast.ExprArrowFunction{
 			Static:     true,
 			ReturnsRef: true,
-			Params: []node.Node{
-				&node.Parameter{
+			Params: []ast.Vertex{
+				&ast.Parameter{
 					ByRef:    true,
 					Variadic: false,
-					Variable: &expr.Variable{
-						VarName: &node.Identifier{Value: "var"},
+					Var: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("var")},
 					},
 				},
 			},
-			ReturnType: &name.FullyQualified{
-				Parts: []node.Node{&name.NamePart{Value: "Foo"}},
+			ReturnType: &ast.NameFullyQualified{
+				Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}},
 			},
-			Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+			Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
 		},
 	})
@@ -1784,8 +1781,8 @@ func TestPrinterPrintExprConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ConstFetch{
-		Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}},
+	p.Print(&ast.ExprConstFetch{
+		Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}},
 	})
 
 	expected := "null"
@@ -1800,9 +1797,9 @@ func TestPrinterPrintEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Empty{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprEmpty{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1818,9 +1815,9 @@ func TestPrinterPrettyPrinterrorSuppress(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ErrorSuppress{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprErrorSuppress{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1836,9 +1833,9 @@ func TestPrinterPrintEval(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Eval{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprEval{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1854,10 +1851,10 @@ func TestPrinterPrintExit(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Exit{
+	p.Print(&ast.ExprExit{
 		Die: false,
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1873,10 +1870,10 @@ func TestPrinterPrintDie(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Exit{
+	p.Print(&ast.ExprExit{
 		Die: true,
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -1892,27 +1889,27 @@ func TestPrinterPrintFunctionCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.FunctionCall{
-		Function: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprFunctionCall{
+		Function: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
 					IsReference: true,
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "a"},
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("a")},
 					},
 				},
-				&node.Argument{
+				&ast.Argument{
 					Variadic: true,
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "c"},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("c")},
 					},
 				},
 			},
@@ -1931,8 +1928,8 @@ func TestPrinterPrintInclude(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Include{
-		Expr: &scalar.String{Value: "'path'"},
+	p.Print(&ast.ExprInclude{
+		Expr: &ast.ScalarString{Value: []byte("'path'")},
 	})
 
 	expected := `include 'path'`
@@ -1947,8 +1944,8 @@ func TestPrinterPrintIncludeOnce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.IncludeOnce{
-		Expr: &scalar.String{Value: "'path'"},
+	p.Print(&ast.ExprIncludeOnce{
+		Expr: &ast.ScalarString{Value: []byte("'path'")},
 	})
 
 	expected := `include_once 'path'`
@@ -1963,11 +1960,11 @@ func TestPrinterPrintInstanceOf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.InstanceOf{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprInstanceOf{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		Class: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
+		Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 	})
 
 	expected := `$var instanceof Foo`
@@ -1982,13 +1979,13 @@ func TestPrinterPrintIsset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Isset{
-		Variables: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprIsset{
+		Vars: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
 	})
@@ -2005,24 +2002,24 @@ func TestPrinterPrintList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.List{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Val: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprList{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				},
 			},
-			&expr.ArrayItem{
-				Val: &expr.List{
-					Items: []node.Node{
-						&expr.ArrayItem{
-							Val: &expr.Variable{
-								VarName: &node.Identifier{Value: "b"},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprList{
+					Items: []ast.Vertex{
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{
+								VarName: &ast.Identifier{Value: []byte("b")},
 							},
 						},
-						&expr.ArrayItem{
-							Val: &expr.Variable{
-								VarName: &node.Identifier{Value: "c"},
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{
+								VarName: &ast.Identifier{Value: []byte("c")},
 							},
 						},
 					},
@@ -2043,21 +2040,21 @@ func TestPrinterPrintMethodCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.MethodCall{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "foo"},
+	p.Print(&ast.ExprMethodCall{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("foo")},
 		},
-		Method: &node.Identifier{Value: "bar"},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "a"},
+		Method: &ast.Identifier{Value: []byte("bar")},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("a")},
 					},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
 			},
@@ -2076,24 +2073,24 @@ func TestPrinterPrintNew(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.New{
-		Class: &name.Name{
-			Parts: []node.Node{
-				&name.NamePart{
-					Value: "Foo",
+	p.Print(&ast.ExprNew{
+		Class: &ast.NameName{
+			Parts: []ast.Vertex{
+				&ast.NameNamePart{
+					Value: []byte("Foo"),
 				},
 			},
 		},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "a"},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("a")},
 					},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
 			},
@@ -2112,9 +2109,9 @@ func TestPrinterPrintPostDec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.PostDec{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprPostDec{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2130,9 +2127,9 @@ func TestPrinterPrintPostInc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.PostInc{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprPostInc{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2148,9 +2145,9 @@ func TestPrinterPrintPreDec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.PreDec{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprPreDec{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2166,9 +2163,9 @@ func TestPrinterPrintPreInc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.PreInc{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprPreInc{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2184,9 +2181,9 @@ func TestPrinterPrintPrint(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Print{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprPrint{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2202,11 +2199,11 @@ func TestPrinterPrintPropertyFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.PropertyFetch{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "foo"},
+	p.Print(&ast.ExprPropertyFetch{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("foo")},
 		},
-		Property: &node.Identifier{Value: "bar"},
+		Property: &ast.Identifier{Value: []byte("bar")},
 	})
 
 	expected := `$foo->bar`
@@ -2221,9 +2218,9 @@ func TestPrinterPrintExprReference(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Reference{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "foo"},
+	p.Print(&ast.ExprReference{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("foo")},
 		},
 	})
 
@@ -2239,8 +2236,8 @@ func TestPrinterPrintRequire(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Require{
-		Expr: &scalar.String{Value: "'path'"},
+	p.Print(&ast.ExprRequire{
+		Expr: &ast.ScalarString{Value: []byte("'path'")},
 	})
 
 	expected := `require 'path'`
@@ -2255,8 +2252,8 @@ func TestPrinterPrintRequireOnce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.RequireOnce{
-		Expr: &scalar.String{Value: "'path'"},
+	p.Print(&ast.ExprRequireOnce{
+		Expr: &ast.ScalarString{Value: []byte("'path'")},
 	})
 
 	expected := `require_once 'path'`
@@ -2271,13 +2268,13 @@ func TestPrinterPrintShellExec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ShellExec{
-		Parts: []node.Node{
-			&scalar.EncapsedStringPart{Value: "hello "},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "world"},
+	p.Print(&ast.ExprShellExec{
+		Parts: []ast.Vertex{
+			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("world")},
 			},
-			&scalar.EncapsedStringPart{Value: "!"},
+			&ast.ScalarEncapsedStringPart{Value: []byte("!")},
 		},
 	})
 
@@ -2293,23 +2290,23 @@ func TestPrinterPrintExprShortArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ShortArray{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Key: &scalar.String{Value: "'Hello'"},
-				Val: &expr.Variable{
-					VarName: &node.Identifier{Value: "world"},
+	p.Print(&ast.ExprShortArray{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarString{Value: []byte("'Hello'")},
+				Val: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("world")},
 				},
 			},
-			&expr.ArrayItem{
-				Key: &scalar.Lnumber{Value: "2"},
-				Val: &expr.Reference{Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "var"},
+			&ast.ExprArrayItem{
+				Key: &ast.ScalarLnumber{Value: []byte("2")},
+				Val: &ast.ExprReference{Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("var")},
 				}},
 			},
-			&expr.ArrayItem{
-				Val: &expr.Variable{
-					VarName: &node.Identifier{Value: "var"},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("var")},
 				},
 			},
 		},
@@ -2327,24 +2324,24 @@ func TestPrinterPrintShortList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.ShortList{
-		Items: []node.Node{
-			&expr.ArrayItem{
-				Val: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprShortList{
+		Items: []ast.Vertex{
+			&ast.ExprArrayItem{
+				Val: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				},
 			},
-			&expr.ArrayItem{
-				Val: &expr.List{
-					Items: []node.Node{
-						&expr.ArrayItem{
-							Val: &expr.Variable{
-								VarName: &node.Identifier{Value: "b"},
+			&ast.ExprArrayItem{
+				Val: &ast.ExprList{
+					Items: []ast.Vertex{
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{
+								VarName: &ast.Identifier{Value: []byte("b")},
 							},
 						},
-						&expr.ArrayItem{
-							Val: &expr.Variable{
-								VarName: &node.Identifier{Value: "c"},
+						&ast.ExprArrayItem{
+							Val: &ast.ExprVariable{
+								VarName: &ast.Identifier{Value: []byte("c")},
 							},
 						},
 					},
@@ -2365,19 +2362,19 @@ func TestPrinterPrintStaticCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.StaticCall{
-		Class: &node.Identifier{Value: "Foo"},
-		Call:  &node.Identifier{Value: "bar"},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprStaticCall{
+		Class: &ast.Identifier{Value: []byte("Foo")},
+		Call:  &ast.Identifier{Value: []byte("bar")},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("a")},
 					},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
 			},
@@ -2396,10 +2393,10 @@ func TestPrinterPrintStaticPropertyFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.StaticPropertyFetch{
-		Class: &node.Identifier{Value: "Foo"},
-		Property: &expr.Variable{
-			VarName: &node.Identifier{Value: "bar"},
+	p.Print(&ast.ExprStaticPropertyFetch{
+		Class: &ast.Identifier{Value: []byte("Foo")},
+		Property: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("bar")},
 		},
 	})
 
@@ -2415,12 +2412,12 @@ func TestPrinterPrintTernary(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Ternary{
-		Condition: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprTernary{
+		Condition: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		IfFalse: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		IfFalse: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
 	})
 
@@ -2436,15 +2433,15 @@ func TestPrinterPrintTernaryFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Ternary{
-		Condition: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.ExprTernary{
+		Condition: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		IfTrue: &expr.Variable{
-			VarName: &node.Identifier{Value: "b"},
+		IfTrue: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("b")},
 		},
-		IfFalse: &expr.Variable{
-			VarName: &node.Identifier{Value: "c"},
+		IfFalse: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("c")},
 		},
 	})
 
@@ -2460,9 +2457,9 @@ func TestPrinterPrintUnaryMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.UnaryMinus{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprUnaryMinus{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2478,9 +2475,9 @@ func TestPrinterPrintUnaryPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.UnaryPlus{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprUnaryPlus{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2496,9 +2493,9 @@ func TestPrinterPrintVariable(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Variable{
-		VarName: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprVariable{
+		VarName: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2514,9 +2511,9 @@ func TestPrinterPrintYieldFrom(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.YieldFrom{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprYieldFrom{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2532,9 +2529,9 @@ func TestPrinterPrintYield(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Yield{
-		Value: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.ExprYield{
+		Value: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2550,12 +2547,12 @@ func TestPrinterPrintYieldFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&expr.Yield{
-		Key: &expr.Variable{
-			VarName: &node.Identifier{Value: "k"},
+	p.Print(&ast.ExprYield{
+		Key: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("k")},
 		},
-		Value: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+		Value: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -2573,14 +2570,14 @@ func TestPrinterPrintAltElseIf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltElseIf{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtAltElseIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				}},
 			},
 		},
@@ -2598,11 +2595,11 @@ func TestPrinterPrintAltElseIfEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltElseIf{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtAltElseIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{},
+		Stmt: &ast.StmtStmtList{},
 	})
 
 	expected := `elseif($a):`
@@ -2617,11 +2614,11 @@ func TestPrinterPrintAltElse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltElse{
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+	p.Print(&ast.StmtAltElse{
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				}},
 			},
 		},
@@ -2639,8 +2636,8 @@ func TestPrinterPrintAltElseEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltElse{
-		Stmt: &stmt.StmtList{},
+	p.Print(&ast.StmtAltElse{
+		Stmt: &ast.StmtStmtList{},
 	})
 
 	expected := `else:`
@@ -2655,26 +2652,26 @@ func TestPrinterPrintAltFor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltFor{
-		Init: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtAltFor{
+		Init: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
 		},
-		Cond: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+		Cond: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
-		Loop: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "c"},
+		Loop: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("c")},
 			},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "d"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("d")},
 				}},
 			},
 		},
@@ -2692,20 +2689,20 @@ func TestPrinterPrintAltForeach(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltForeach{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.StmtAltForeach{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		Key: &expr.Variable{
-			VarName: &node.Identifier{Value: "key"},
+		Key: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("key")},
 		},
-		Variable: &expr.Reference{Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "val"},
+		Var: &ast.ExprReference{Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("val")},
 		}},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "d"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("d")},
 				}},
 			},
 		},
@@ -2723,42 +2720,42 @@ func TestPrinterPrintAltIf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltIf{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtAltIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "d"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("d")},
 				}},
 			},
 		},
-		ElseIf: []node.Node{
-			&stmt.AltElseIf{
-				Cond: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+		ElseIf: []ast.Vertex{
+			&ast.StmtAltElseIf{
+				Cond: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "b"},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("b")},
 						}},
 					},
 				},
 			},
-			&stmt.AltElseIf{
-				Cond: &expr.Variable{
-					VarName: &node.Identifier{Value: "c"},
+			&ast.StmtAltElseIf{
+				Cond: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("c")},
 				},
-				Stmt: &stmt.StmtList{},
+				Stmt: &ast.StmtStmtList{},
 			},
 		},
-		Else: &stmt.AltElse{
-			Stmt: &stmt.StmtList{
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+		Else: &ast.StmtAltElse{
+			Stmt: &ast.StmtStmtList{
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					}},
 				},
 			},
@@ -2777,25 +2774,25 @@ func TestPrinterPrintStmtAltSwitch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltSwitch{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.StmtAltSwitch{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		CaseList: &stmt.CaseList{
-			Cases: []node.Node{
-				&stmt.Case{
-					Cond: &scalar.String{Value: "'a'"},
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "a"},
+		CaseList: &ast.StmtCaseList{
+			Cases: []ast.Vertex{
+				&ast.StmtCase{
+					Cond: &ast.ScalarString{Value: []byte("'a'")},
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("a")},
 						}},
 					},
 				},
-				&stmt.Case{
-					Cond: &scalar.String{Value: "'b'"},
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "b"},
+				&ast.StmtCase{
+					Cond: &ast.ScalarString{Value: []byte("'b'")},
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("b")},
 						}},
 					},
 				},
@@ -2815,14 +2812,14 @@ func TestPrinterPrintAltWhile(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.AltWhile{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtAltWhile{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				}},
 			},
 		},
@@ -2840,9 +2837,9 @@ func TestPrinterPrintStmtBreak(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Break{
-		Expr: &scalar.Lnumber{
-			Value: "1",
+	p.Print(&ast.StmtBreak{
+		Expr: &ast.ScalarLnumber{
+			Value: []byte("1"),
 		},
 	})
 
@@ -2858,13 +2855,13 @@ func TestPrinterPrintStmtCase(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Case{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtCase{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
 		},
 	})
@@ -2881,11 +2878,11 @@ func TestPrinterPrintStmtCaseEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Case{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtCase{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmts: []node.Node{},
+		Stmts: []ast.Vertex{},
 	})
 
 	expected := "case $a:"
@@ -2900,17 +2897,17 @@ func TestPrinterPrintStmtCatch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Catch{
-		Types: []node.Node{
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
-			&name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+	p.Print(&ast.StmtCatch{
+		Types: []ast.Vertex{
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+			&ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
 		},
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "e"},
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("e")},
 		},
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
 		},
 	})
@@ -2927,33 +2924,33 @@ func TestPrinterPrintStmtClassMethod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ClassMethod{
-		Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
+	p.Print(&ast.StmtClassMethod{
+		Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
 		ReturnsRef: true,
-		MethodName: &node.Identifier{Value: "foo"},
-		Params: []node.Node{
-			&node.Parameter{
-				ByRef:        true,
-				VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+		MethodName: &ast.Identifier{Value: []byte("foo")},
+		Params: []ast.Vertex{
+			&ast.Parameter{
+				ByRef: true,
+				Type:  &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				},
-				DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+				DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
 			},
-			&node.Parameter{
+			&ast.Parameter{
 				Variadic: true,
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				},
 			},
 		},
-		ReturnType: &name.Name{
-			Parts: []node.Node{&name.NamePart{Value: "void"}},
+		ReturnType: &ast.NameName{
+			Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				}},
 			},
 		},
@@ -2971,33 +2968,33 @@ func TestPrinterPrintStmtAbstractClassMethod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ClassMethod{
-		Modifiers: []node.Node{
-			&node.Identifier{Value: "public"},
-			&node.Identifier{Value: "static"},
+	p.Print(&ast.StmtClassMethod{
+		Modifiers: []ast.Vertex{
+			&ast.Identifier{Value: []byte("public")},
+			&ast.Identifier{Value: []byte("static")},
 		},
 		ReturnsRef: true,
-		MethodName: &node.Identifier{Value: "foo"},
-		Params: []node.Node{
-			&node.Parameter{
-				ByRef:        true,
-				VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+		MethodName: &ast.Identifier{Value: []byte("foo")},
+		Params: []ast.Vertex{
+			&ast.Parameter{
+				ByRef: true,
+				Type:  &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				},
-				DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+				DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
 			},
-			&node.Parameter{
+			&ast.Parameter{
 				Variadic: true,
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				},
 			},
 		},
-		ReturnType: &name.Name{
-			Parts: []node.Node{&name.NamePart{Value: "void"}},
+		ReturnType: &ast.NameName{
+			Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}},
 		},
-		Stmt: &stmt.Nop{},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `public static function &foo(?int&$a=null,...$b):void;`
@@ -3012,28 +3009,28 @@ func TestPrinterPrintStmtClass(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Class{
-		Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
-		ClassName: &node.Identifier{Value: "Foo"},
-		Extends: &stmt.ClassExtends{
-			ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+	p.Print(&ast.StmtClass{
+		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+		ClassName: &ast.Identifier{Value: []byte("Foo")},
+		Extends: &ast.StmtClassExtends{
+			ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 		},
-		Implements: &stmt.ClassImplements{
-			InterfaceNames: []node.Node{
-				&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
-				&name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+		Implements: &ast.StmtClassImplements{
+			InterfaceNames: []ast.Vertex{
+				&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+				&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
 			},
 		},
-		Stmts: []node.Node{
-			&stmt.ClassConstList{
-				Modifiers: []node.Node{
-					&node.Identifier{Value: "public"},
-					&node.Identifier{Value: "static"},
+		Stmts: []ast.Vertex{
+			&ast.StmtClassConstList{
+				Modifiers: []ast.Vertex{
+					&ast.Identifier{Value: []byte("public")},
+					&ast.Identifier{Value: []byte("static")},
 				},
-				Consts: []node.Node{
-					&stmt.Constant{
-						ConstantName: &node.Identifier{Value: "FOO"},
-						Expr:         &scalar.String{Value: "'bar'"},
+				Consts: []ast.Vertex{
+					&ast.StmtConstant{
+						ConstantName: &ast.Identifier{Value: []byte("FOO")},
+						Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 					},
 				},
 			},
@@ -3052,38 +3049,38 @@ func TestPrinterPrintStmtAnonymousClass(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Class{
-		Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
-		ArgumentList: &node.ArgumentList{
-			Arguments: []node.Node{
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtClass{
+		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+		ArgumentList: &ast.ArgumentList{
+			Arguments: []ast.Vertex{
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("a")},
 					},
 				},
-				&node.Argument{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+				&ast.Argument{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
 			},
 		},
-		Extends: &stmt.ClassExtends{
-			ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+		Extends: &ast.StmtClassExtends{
+			ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 		},
-		Implements: &stmt.ClassImplements{
-			InterfaceNames: []node.Node{
-				&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
-				&name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+		Implements: &ast.StmtClassImplements{
+			InterfaceNames: []ast.Vertex{
+				&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+				&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
 			},
 		},
-		Stmts: []node.Node{
-			&stmt.ClassConstList{
-				Modifiers: []node.Node{&node.Identifier{Value: "public"}},
-				Consts: []node.Node{
-					&stmt.Constant{
-						ConstantName: &node.Identifier{Value: "FOO"},
-						Expr:         &scalar.String{Value: "'bar'"},
+		Stmts: []ast.Vertex{
+			&ast.StmtClassConstList{
+				Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+				Consts: []ast.Vertex{
+					&ast.StmtConstant{
+						ConstantName: &ast.Identifier{Value: []byte("FOO")},
+						Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 					},
 				},
 			},
@@ -3102,16 +3099,16 @@ func TestPrinterPrintStmtClassConstList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ClassConstList{
-		Modifiers: []node.Node{&node.Identifier{Value: "public"}},
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'a'"},
+	p.Print(&ast.StmtClassConstList{
+		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'a'")},
 			},
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "BAR"},
-				Expr:         &scalar.String{Value: "'b'"},
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("BAR")},
+				Expr:         &ast.ScalarString{Value: []byte("'b'")},
 			},
 		},
 	})
@@ -3128,15 +3125,15 @@ func TestPrinterPrintStmtConstList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ConstList{
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'a'"},
+	p.Print(&ast.StmtConstList{
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'a'")},
 			},
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "BAR"},
-				Expr:         &scalar.String{Value: "'b'"},
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("BAR")},
+				Expr:         &ast.ScalarString{Value: []byte("'b'")},
 			},
 		},
 	})
@@ -3153,9 +3150,9 @@ func TestPrinterPrintStmtConstant(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Constant{
-		ConstantName: &node.Identifier{Value: "FOO"},
-		Expr:         &scalar.String{Value: "'BAR'"},
+	p.Print(&ast.StmtConstant{
+		ConstantName: &ast.Identifier{Value: []byte("FOO")},
+		Expr:         &ast.ScalarString{Value: []byte("'BAR'")},
 	})
 
 	expected := "FOO='BAR'"
@@ -3170,9 +3167,9 @@ func TestPrinterPrintStmtContinue(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Continue{
-		Expr: &scalar.Lnumber{
-			Value: "1",
+	p.Print(&ast.StmtContinue{
+		Expr: &ast.ScalarLnumber{
+			Value: []byte("1"),
 		},
 	})
 
@@ -3188,16 +3185,16 @@ func TestPrinterPrintStmtDeclareStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Declare{
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'bar'"},
+	p.Print(&ast.StmtDeclare{
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 			},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -3214,14 +3211,14 @@ func TestPrinterPrintStmtDeclareExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Declare{
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'bar'"},
+	p.Print(&ast.StmtDeclare{
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 			},
 		},
-		Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 	})
 
 	expected := `declare(FOO='bar')'bar';`
@@ -3236,14 +3233,14 @@ func TestPrinterPrintStmtDeclareNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Declare{
-		Consts: []node.Node{
-			&stmt.Constant{
-				ConstantName: &node.Identifier{Value: "FOO"},
-				Expr:         &scalar.String{Value: "'bar'"},
+	p.Print(&ast.StmtDeclare{
+		Consts: []ast.Vertex{
+			&ast.StmtConstant{
+				ConstantName: &ast.Identifier{Value: []byte("FOO")},
+				Expr:         &ast.ScalarString{Value: []byte("'bar'")},
 			},
 		},
-		Stmt: &stmt.Nop{},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `declare(FOO='bar');`
@@ -3258,10 +3255,10 @@ func TestPrinterPrintStmtDefalut(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Default{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtDefault{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
 		},
 	})
@@ -3278,8 +3275,8 @@ func TestPrinterPrintStmtDefalutEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Default{
-		Stmts: []node.Node{},
+	p.Print(&ast.StmtDefault{
+		Stmts: []ast.Vertex{},
 	})
 
 	expected := `default:`
@@ -3294,11 +3291,11 @@ func TestPrinterPrintStmtDo_Expression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Do{
-		Cond: &scalar.Lnumber{Value: "1"},
-		Stmt: &stmt.Expression{
-			Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtDo{
+		Cond: &ast.ScalarLnumber{Value: []byte("1")},
+		Stmt: &ast.StmtExpression{
+			Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
 		},
 	})
@@ -3315,12 +3312,12 @@ func TestPrinterPrintStmtDo_StmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Do{
-		Cond: &scalar.Lnumber{Value: "1"},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtDo{
+		Cond: &ast.ScalarLnumber{Value: []byte("1")},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				}},
 			},
 		},
@@ -3338,15 +3335,15 @@ func TestPrinterPrintStmtEchoHtmlState(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Root{
-		Stmts: []node.Node{
-			&stmt.Echo{
-				Exprs: []node.Node{
-					&expr.Variable{
-						VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.Root{
+		Stmts: []ast.Vertex{
+			&ast.StmtEcho{
+				Exprs: []ast.Vertex{
+					&ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("a")},
 					},
-					&expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+					&ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
 			},
@@ -3365,13 +3362,13 @@ func TestPrinterPrintStmtEchoPhpState(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Echo{
-		Exprs: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtEcho{
+		Exprs: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
 	})
@@ -3388,13 +3385,13 @@ func TestPrinterPrintStmtElseIfStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ElseIf{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtElseIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -3411,11 +3408,11 @@ func TestPrinterPrintStmtElseIfExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ElseIf{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtElseIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 	})
 
 	expected := `elseif($a)'bar';`
@@ -3430,11 +3427,11 @@ func TestPrinterPrintStmtElseIfNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.ElseIf{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtElseIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.Nop{},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `elseif($a);`
@@ -3449,10 +3446,10 @@ func TestPrinterPrintStmtElseStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Else{
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+	p.Print(&ast.StmtElse{
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -3469,8 +3466,8 @@ func TestPrinterPrintStmtElseExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Else{
-		Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+	p.Print(&ast.StmtElse{
+		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
 	})
 
 	expected := `else 'bar';`
@@ -3485,8 +3482,8 @@ func TestPrinterPrintStmtElseNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Else{
-		Stmt: &stmt.Nop{},
+	p.Print(&ast.StmtElse{
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `else ;`
@@ -3501,9 +3498,9 @@ func TestPrinterPrintExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Expression{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtExpression{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
 	})
 
@@ -3519,9 +3516,9 @@ func TestPrinterPrintStmtFinally(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Finally{
-		Stmts: []node.Node{
-			&stmt.Nop{},
+	p.Print(&ast.StmtFinally{
+		Stmts: []ast.Vertex{
+			&ast.StmtNop{},
 		},
 	})
 
@@ -3537,34 +3534,34 @@ func TestPrinterPrintStmtFor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.For{
-		Init: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtFor{
+		Init: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
-		Cond: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "c"},
+		Cond: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("c")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "d"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("d")},
 			},
 		},
-		Loop: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "e"},
+		Loop: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("e")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "f"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("f")},
 			},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -3581,19 +3578,19 @@ func TestPrinterPrintStmtForeach(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Foreach{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtForeach{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Key: &expr.Variable{
-			VarName: &node.Identifier{Value: "k"},
+		Key: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("k")},
 		},
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "v"},
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("v")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -3610,23 +3607,23 @@ func TestPrinterPrintStmtFunction(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Function{
+	p.Print(&ast.StmtFunction{
 		ReturnsRef:   true,
-		FunctionName: &node.Identifier{Value: "foo"},
-		Params: []node.Node{
-			&node.Parameter{
+		FunctionName: &ast.Identifier{Value: []byte("foo")},
+		Params: []ast.Vertex{
+			&ast.Parameter{
 				ByRef:    true,
 				Variadic: false,
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "var"},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("var")},
 				},
 			},
 		},
-		ReturnType: &name.FullyQualified{
-			Parts: []node.Node{&name.NamePart{Value: "Foo"}},
+		ReturnType: &ast.NameFullyQualified{
+			Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}},
 		},
-		Stmts: []node.Node{
-			&stmt.Nop{},
+		Stmts: []ast.Vertex{
+			&ast.StmtNop{},
 		},
 	})
 
@@ -3642,13 +3639,13 @@ func TestPrinterPrintStmtGlobal(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Global{
-		Vars: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtGlobal{
+		Vars: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
 	})
@@ -3665,8 +3662,8 @@ func TestPrinterPrintStmtGoto(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Goto{
-		Label: &node.Identifier{Value: "FOO"},
+	p.Print(&ast.StmtGoto{
+		Label: &ast.Identifier{Value: []byte("FOO")},
 	})
 
 	expected := `goto FOO;`
@@ -3681,16 +3678,16 @@ func TestPrinterPrintStmtGroupUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.GroupUse{
-		UseType: &node.Identifier{Value: "function"},
-		Prefix:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		UseList: []node.Node{
-			&stmt.Use{
-				Use:   &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
-				Alias: &node.Identifier{Value: "Baz"},
+	p.Print(&ast.StmtGroupUse{
+		UseType: &ast.Identifier{Value: []byte("function")},
+		Prefix:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		UseList: []ast.Vertex{
+			&ast.StmtUse{
+				Use:   &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+				Alias: &ast.Identifier{Value: []byte("Baz")},
 			},
-			&stmt.Use{
-				Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+			&ast.StmtUse{
+				Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
 			},
 		},
 	})
@@ -3707,7 +3704,7 @@ func TestPrinterPrintHaltCompiler(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.HaltCompiler{})
+	p.Print(&ast.StmtHaltCompiler{})
 
 	expected := `__halt_compiler();`
 	actual := o.String()
@@ -3721,41 +3718,41 @@ func TestPrinterPrintIfExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.If{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.Expression{
-			Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+		Stmt: &ast.StmtExpression{
+			Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
-		ElseIf: []node.Node{
-			&stmt.ElseIf{
-				Cond: &expr.Variable{
-					VarName: &node.Identifier{Value: "c"},
+		ElseIf: []ast.Vertex{
+			&ast.StmtElseIf{
+				Cond: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("c")},
 				},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{
-							Expr: &expr.Variable{
-								VarName: &node.Identifier{Value: "d"},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{
+							Expr: &ast.ExprVariable{
+								VarName: &ast.Identifier{Value: []byte("d")},
 							},
 						},
 					},
 				},
 			},
-			&stmt.ElseIf{
-				Cond: &expr.Variable{
-					VarName: &node.Identifier{Value: "e"},
+			&ast.StmtElseIf{
+				Cond: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("e")},
 				},
-				Stmt: &stmt.Nop{},
+				Stmt: &ast.StmtNop{},
 			},
 		},
-		Else: &stmt.Else{
-			Stmt: &stmt.Expression{
-				Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "f"},
+		Else: &ast.StmtElse{
+			Stmt: &ast.StmtExpression{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("f")},
 				},
 			},
 		},
@@ -3773,15 +3770,15 @@ func TestPrinterPrintIfStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.If{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{
-					Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{
+					Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					},
 				},
 			},
@@ -3800,11 +3797,11 @@ func TestPrinterPrintIfNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.If{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtIf{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.Nop{},
+		Stmt: &ast.StmtNop{},
 	})
 
 	expected := `if($a);`
@@ -3819,10 +3816,10 @@ func TestPrinterPrintInlineHtml(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&node.Root{
-		Stmts: []node.Node{
-			&stmt.InlineHtml{
-				Value: "test",
+	p.Print(&ast.Root{
+		Stmts: []ast.Vertex{
+			&ast.StmtInlineHtml{
+				Value: []byte("test"),
 			},
 		},
 	})
@@ -3839,23 +3836,23 @@ func TestPrinterPrintInterface(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Interface{
-		InterfaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Extends: &stmt.InterfaceExtends{
-			InterfaceNames: []node.Node{
-				&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
-				&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+	p.Print(&ast.StmtInterface{
+		InterfaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Extends: &ast.StmtInterfaceExtends{
+			InterfaceNames: []ast.Vertex{
+				&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+				&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 			},
 		},
-		Stmts: []node.Node{
-			&stmt.ClassMethod{
-				Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
-				MethodName: &node.Identifier{Value: "foo"},
-				Params:     []node.Node{},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "a"},
+		Stmts: []ast.Vertex{
+			&ast.StmtClassMethod{
+				Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+				MethodName: &ast.Identifier{Value: []byte("foo")},
+				Params:     []ast.Vertex{},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("a")},
 						}},
 					},
 				},
@@ -3875,8 +3872,8 @@ func TestPrinterPrintLabel(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Label{
-		LabelName: &node.Identifier{Value: "FOO"},
+	p.Print(&ast.StmtLabel{
+		LabelName: &ast.Identifier{Value: []byte("FOO")},
 	})
 
 	expected := `FOO:`
@@ -3891,8 +3888,8 @@ func TestPrinterPrintNamespace(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Namespace{
-		NamespaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
+	p.Print(&ast.StmtNamespace{
+		NamespaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 	})
 
 	expected := `namespace Foo;`
@@ -3907,11 +3904,11 @@ func TestPrinterPrintNamespaceWithStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Namespace{
-		NamespaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtNamespace{
+		NamespaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
 		},
 	})
@@ -3928,7 +3925,7 @@ func TestPrinterPrintNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Nop{})
+	p.Print(&ast.StmtNop{})
 
 	expected := `;`
 	actual := o.String()
@@ -3942,28 +3939,28 @@ func TestPrinterPrintPropertyList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.PropertyList{
-		Modifiers: []node.Node{
-			&node.Identifier{Value: "public"},
-			&node.Identifier{Value: "static"},
+	p.Print(&ast.StmtPropertyList{
+		Modifiers: []ast.Vertex{
+			&ast.Identifier{Value: []byte("public")},
+			&ast.Identifier{Value: []byte("static")},
 		},
-		Type: &name.Name{
-			Parts: []node.Node{
-				&name.NamePart{
-					Value: "Foo",
+		Type: &ast.NameName{
+			Parts: []ast.Vertex{
+				&ast.NameNamePart{
+					Value: []byte("Foo"),
 				},
 			},
 		},
-		Properties: []node.Node{
-			&stmt.Property{
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+		Properties: []ast.Vertex{
+			&ast.StmtProperty{
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				},
-				Expr: &scalar.String{Value: "'a'"},
+				Expr: &ast.ScalarString{Value: []byte("'a'")},
 			},
-			&stmt.Property{
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+			&ast.StmtProperty{
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				},
 			},
 		},
@@ -3981,19 +3978,21 @@ func TestPrinterPrintProperty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Property{
-		Variable: &expr.Variable{
-			FreeFloating: freefloating.Collection{
-				freefloating.Start: []freefloating.String{
-					{
-						StringType: freefloating.TokenType,
-						Value:      "$",
+	p.Print(&ast.StmtProperty{
+		Var: &ast.ExprVariable{
+			Node: ast.Node{
+				Tokens: token.Collection{
+					token.Start: []token.Token{
+						{
+							ID:    token.ID('$'),
+							Value: []byte("$"),
+						},
 					},
 				},
 			},
-			VarName: &node.Identifier{Value: "a"},
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expr: &scalar.Lnumber{Value: "1"},
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `$a=1`
@@ -4008,8 +4007,8 @@ func TestPrinterPrintReturn(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Return{
-		Expr: &scalar.Lnumber{Value: "1"},
+	p.Print(&ast.StmtReturn{
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `return 1;`
@@ -4024,11 +4023,11 @@ func TestPrinterPrintStaticVar(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.StaticVar{
-		Variable: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtStaticVar{
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Expr: &scalar.Lnumber{Value: "1"},
+		Expr: &ast.ScalarLnumber{Value: []byte("1")},
 	})
 
 	expected := `$a=1`
@@ -4043,16 +4042,16 @@ func TestPrinterPrintStatic(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Static{
-		Vars: []node.Node{
-			&stmt.StaticVar{
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtStatic{
+		Vars: []ast.Vertex{
+			&ast.StmtStaticVar{
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				},
 			},
-			&stmt.StaticVar{
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "b"},
+			&ast.StmtStaticVar{
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("b")},
 				},
 			},
 		},
@@ -4070,13 +4069,13 @@ func TestPrinterPrintStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			}},
 		},
 	})
@@ -4093,20 +4092,20 @@ func TestPrinterPrintStmtListNested(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.StmtList{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtStmtList{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
-			&stmt.StmtList{
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+			&ast.StmtStmtList{
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					}},
-					&stmt.StmtList{
-						Stmts: []node.Node{
-							&stmt.Expression{Expr: &expr.Variable{
-								VarName: &node.Identifier{Value: "c"},
+					&ast.StmtStmtList{
+						Stmts: []ast.Vertex{
+							&ast.StmtExpression{Expr: &ast.ExprVariable{
+								VarName: &ast.Identifier{Value: []byte("c")},
 							}},
 						},
 					},
@@ -4127,25 +4126,25 @@ func TestPrinterPrintStmtSwitch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Switch{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.StmtSwitch{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
-		CaseList: &stmt.CaseList{
-			Cases: []node.Node{
-				&stmt.Case{
-					Cond: &scalar.String{Value: "'a'"},
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "a"},
+		CaseList: &ast.StmtCaseList{
+			Cases: []ast.Vertex{
+				&ast.StmtCase{
+					Cond: &ast.ScalarString{Value: []byte("'a'")},
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("a")},
 						}},
 					},
 				},
-				&stmt.Case{
-					Cond: &scalar.String{Value: "'b'"},
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "b"},
+				&ast.StmtCase{
+					Cond: &ast.ScalarString{Value: []byte("'b'")},
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("b")},
 						}},
 					},
 				},
@@ -4165,9 +4164,9 @@ func TestPrinterPrintStmtThrow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Throw{
-		Expr: &expr.Variable{
-			VarName: &node.Identifier{Value: "var"},
+	p.Print(&ast.StmtThrow{
+		Expr: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("var")},
 		},
 	})
 
@@ -4183,14 +4182,14 @@ func TestPrinterPrintStmtTraitAdaptationList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitAdaptationList{
-		Adaptations: []node.Node{
-			&stmt.TraitUseAlias{
-				Ref: &stmt.TraitMethodRef{
-					Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-					Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitAdaptationList{
+		Adaptations: []ast.Vertex{
+			&ast.StmtTraitUseAlias{
+				Ref: &ast.StmtTraitMethodRef{
+					Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+					Method: &ast.Identifier{Value: []byte("a")},
 				},
-				Alias: &node.Identifier{Value: "b"},
+				Alias: &ast.Identifier{Value: []byte("b")},
 			},
 		},
 	})
@@ -4207,8 +4206,8 @@ func TestPrinterPrintStmtTraitMethodRef(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitMethodRef{
-		Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitMethodRef{
+		Method: &ast.Identifier{Value: []byte("a")},
 	})
 
 	expected := `a`
@@ -4223,9 +4222,9 @@ func TestPrinterPrintStmtTraitMethodRefFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitMethodRef{
-		Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitMethodRef{
+		Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Method: &ast.Identifier{Value: []byte("a")},
 	})
 
 	expected := `Foo::a`
@@ -4240,13 +4239,13 @@ func TestPrinterPrintStmtTraitUseAlias(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitUseAlias{
-		Ref: &stmt.TraitMethodRef{
-			Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitUseAlias{
+		Ref: &ast.StmtTraitMethodRef{
+			Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			Method: &ast.Identifier{Value: []byte("a")},
 		},
-		Modifier: &node.Identifier{Value: "public"},
-		Alias:    &node.Identifier{Value: "b"},
+		Modifier: &ast.Identifier{Value: []byte("public")},
+		Alias:    &ast.Identifier{Value: []byte("b")},
 	})
 
 	expected := `Foo::a as public b;`
@@ -4261,14 +4260,14 @@ func TestPrinterPrintStmtTraitUsePrecedence(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitUsePrecedence{
-		Ref: &stmt.TraitMethodRef{
-			Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			Method: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTraitUsePrecedence{
+		Ref: &ast.StmtTraitMethodRef{
+			Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			Method: &ast.Identifier{Value: []byte("a")},
 		},
-		Insteadof: []node.Node{
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+		Insteadof: []ast.Vertex{
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 		},
 	})
 
@@ -4284,12 +4283,12 @@ func TestPrinterPrintStmtTraitUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitUse{
-		Traits: []node.Node{
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+	p.Print(&ast.StmtTraitUse{
+		Traits: []ast.Vertex{
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 		},
-		TraitAdaptationList: &stmt.Nop{},
+		TraitAdaptationList: &ast.StmtNop{},
 	})
 
 	expected := `use Foo,Bar;`
@@ -4304,19 +4303,19 @@ func TestPrinterPrintStmtTraitAdaptations(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.TraitUse{
-		Traits: []node.Node{
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-			&name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+	p.Print(&ast.StmtTraitUse{
+		Traits: []ast.Vertex{
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 		},
-		TraitAdaptationList: &stmt.TraitAdaptationList{
-			Adaptations: []node.Node{
-				&stmt.TraitUseAlias{
-					Ref: &stmt.TraitMethodRef{
-						Trait:  &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-						Method: &node.Identifier{Value: "a"},
+		TraitAdaptationList: &ast.StmtTraitAdaptationList{
+			Adaptations: []ast.Vertex{
+				&ast.StmtTraitUseAlias{
+					Ref: &ast.StmtTraitMethodRef{
+						Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+						Method: &ast.Identifier{Value: []byte("a")},
 					},
-					Alias: &node.Identifier{Value: "b"},
+					Alias: &ast.Identifier{Value: []byte("b")},
 				},
 			},
 		},
@@ -4334,17 +4333,17 @@ func TestPrinterPrintTrait(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Trait{
-		TraitName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Stmts: []node.Node{
-			&stmt.ClassMethod{
-				Modifiers:  []node.Node{&node.Identifier{Value: "public"}},
-				MethodName: &node.Identifier{Value: "foo"},
-				Params:     []node.Node{},
-				Stmt: &stmt.StmtList{
-					Stmts: []node.Node{
-						&stmt.Expression{Expr: &expr.Variable{
-							VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTrait{
+		TraitName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Stmts: []ast.Vertex{
+			&ast.StmtClassMethod{
+				Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+				MethodName: &ast.Identifier{Value: []byte("foo")},
+				Params:     []ast.Vertex{},
+				Stmt: &ast.StmtStmtList{
+					Stmts: []ast.Vertex{
+						&ast.StmtExpression{Expr: &ast.ExprVariable{
+							VarName: &ast.Identifier{Value: []byte("a")},
 						}},
 					},
 				},
@@ -4364,31 +4363,31 @@ func TestPrinterPrintStmtTry(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Try{
-		Stmts: []node.Node{
-			&stmt.Expression{Expr: &expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtTry{
+		Stmts: []ast.Vertex{
+			&ast.StmtExpression{Expr: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			}},
 		},
-		Catches: []node.Node{
-			&stmt.Catch{
-				Types: []node.Node{
-					&name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
-					&name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+		Catches: []ast.Vertex{
+			&ast.StmtCatch{
+				Types: []ast.Vertex{
+					&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+					&ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
 				},
-				Variable: &expr.Variable{
-					VarName: &node.Identifier{Value: "e"},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("e")},
 				},
-				Stmts: []node.Node{
-					&stmt.Expression{Expr: &expr.Variable{
-						VarName: &node.Identifier{Value: "b"},
+				Stmts: []ast.Vertex{
+					&ast.StmtExpression{Expr: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("b")},
 					}},
 				},
 			},
 		},
-		Finally: &stmt.Finally{
-			Stmts: []node.Node{
-				&stmt.Nop{},
+		Finally: &ast.StmtFinally{
+			Stmts: []ast.Vertex{
+				&ast.StmtNop{},
 			},
 		},
 	})
@@ -4405,13 +4404,13 @@ func TestPrinterPrintStmtUnset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Unset{
-		Vars: []node.Node{
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtUnset{
+		Vars: []ast.Vertex{
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("a")},
 			},
-			&expr.Variable{
-				VarName: &node.Identifier{Value: "b"},
+			&ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("b")},
 			},
 		},
 	})
@@ -4428,15 +4427,15 @@ func TestPrinterPrintStmtUseList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.UseList{
-		UseType: &node.Identifier{Value: "function"},
-		Uses: []node.Node{
-			&stmt.Use{
-				Use:   &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-				Alias: &node.Identifier{Value: "Bar"},
+	p.Print(&ast.StmtUseList{
+		UseType: &ast.Identifier{Value: []byte("function")},
+		Uses: []ast.Vertex{
+			&ast.StmtUse{
+				Use:   &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+				Alias: &ast.Identifier{Value: []byte("Bar")},
 			},
-			&stmt.Use{
-				Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+			&ast.StmtUse{
+				Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 			},
 		},
 	})
@@ -4453,10 +4452,10 @@ func TestPrinterPrintUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.Use{
-		UseType: &node.Identifier{Value: "function"},
-		Use:     &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
-		Alias:   &node.Identifier{Value: "Bar"},
+	p.Print(&ast.StmtUse{
+		UseType: &ast.Identifier{Value: []byte("function")},
+		Use:     &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+		Alias:   &ast.Identifier{Value: []byte("Bar")},
 	})
 
 	expected := `function Foo as Bar`
@@ -4471,14 +4470,14 @@ func TestPrinterPrintWhileStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
 	p := printer.NewPrinter(o)
-	p.Print(&stmt.While{
-		Cond: &expr.Variable{
-			VarName: &node.Identifier{Value: "a"},
+	p.Print(&ast.StmtWhile{
+		Cond: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("a")},
 		},
-		Stmt: &stmt.StmtList{
-			Stmts: []node.Node{
-				&stmt.Expression{Expr: &expr.Variable{
-					VarName: &node.Identifier{Value: "a"},
+		Stmt: &ast.StmtStmtList{
+			Stmts: []ast.Vertex{
+				&ast.StmtExpression{Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("a")},
 				}},
 			},
 		},
diff --git a/pkg/token/position.go b/pkg/token/position.go
index 209ed9d..7032e5a 100644
--- a/pkg/token/position.go
+++ b/pkg/token/position.go
@@ -2,8 +2,6 @@ package token
 
 type Position int
 
-type Collection map[Position][]Token
-
 //go:generate stringer -type=Position -output ./position_string.go
 const (
 	Start Position = iota
@@ -86,3 +84,14 @@ const (
 	OpenParenthesisToken
 	CloseParenthesisToken
 )
+
+type Collection map[Position][]Token
+
+func (c Collection) IsEmpty() bool {
+	for _, v := range c {
+		if len(v) > 0 {
+			return false
+		}
+	}
+	return true
+}
diff --git a/printer/printer.go b/printer/printer.go
deleted file mode 100644
index 06ad2ae..0000000
--- a/printer/printer.go
+++ /dev/null
@@ -1,3267 +0,0 @@
-package printer
-
-import (
-	"io"
-	"strings"
-
-	"github.com/z7zmey/php-parser/freefloating"
-
-	"github.com/z7zmey/php-parser/node/stmt"
-
-	"github.com/z7zmey/php-parser/node"
-	"github.com/z7zmey/php-parser/node/expr"
-	"github.com/z7zmey/php-parser/node/expr/assign"
-	"github.com/z7zmey/php-parser/node/expr/binary"
-	"github.com/z7zmey/php-parser/node/expr/cast"
-	"github.com/z7zmey/php-parser/node/name"
-	"github.com/z7zmey/php-parser/node/scalar"
-)
-
-type printerState int
-
-const (
-	PhpState printerState = iota
-	HtmlState
-)
-
-type Printer struct {
-	w io.Writer
-	s printerState
-}
-
-// NewPrinter -  Constructor for Printer
-func NewPrinter(w io.Writer) *Printer {
-	return &Printer{
-		w: w,
-	}
-}
-
-func (p *Printer) SetState(s printerState) {
-	p.s = s
-}
-
-func (p *Printer) Print(n node.Node) {
-	_, isRoot := n.(*node.Root)
-	_, isInlineHtml := n.(*stmt.InlineHtml)
-	if p.s == HtmlState && !isInlineHtml && !isRoot {
-		if n.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, "<?php ")
-		}
-		p.SetState(PhpState)
-	}
-
-	p.printNode(n)
-}
-
-func (p *Printer) joinPrint(glue string, nn []node.Node) {
-	for k, n := range nn {
-		if k > 0 {
-			io.WriteString(p.w, glue)
-		}
-
-		p.Print(n)
-	}
-}
-
-func (p *Printer) printNodes(nn []node.Node) {
-	for _, n := range nn {
-		p.Print(n)
-	}
-}
-
-func (p *Printer) printFreeFloating(n node.Node, pos freefloating.Position) {
-	if n == nil {
-		return
-	}
-
-	for _, m := range (*n.GetFreeFloating())[pos] {
-		io.WriteString(p.w, m.Value)
-	}
-}
-
-func (p *Printer) printNode(n node.Node) {
-	switch n.(type) {
-
-	// node
-
-	case *node.Root:
-		p.printNodeRoot(n)
-	case *node.Identifier:
-		p.printNodeIdentifier(n)
-	case *node.Parameter:
-		p.printNodeParameter(n)
-	case *node.Nullable:
-		p.printNodeNullable(n)
-	case *node.Argument:
-		p.printNodeArgument(n)
-
-	// name
-
-	case *name.NamePart:
-		p.printNameNamePart(n)
-	case *name.Name:
-		p.printNameName(n)
-	case *name.FullyQualified:
-		p.printNameFullyQualified(n)
-	case *name.Relative:
-		p.printNameRelative(n)
-
-	// scalar
-
-	case *scalar.Lnumber:
-		p.printScalarLNumber(n)
-	case *scalar.Dnumber:
-		p.printScalarDNumber(n)
-	case *scalar.String:
-		p.printScalarString(n)
-	case *scalar.EncapsedStringPart:
-		p.printScalarEncapsedStringPart(n)
-	case *scalar.Encapsed:
-		p.printScalarEncapsed(n)
-	case *scalar.Heredoc:
-		p.printScalarHeredoc(n)
-	case *scalar.MagicConstant:
-		p.printScalarMagicConstant(n)
-
-	// assign
-
-	case *assign.Assign:
-		p.printAssign(n)
-	case *assign.Reference:
-		p.printAssignReference(n)
-	case *assign.BitwiseAnd:
-		p.printAssignBitwiseAnd(n)
-	case *assign.BitwiseOr:
-		p.printAssignBitwiseOr(n)
-	case *assign.BitwiseXor:
-		p.printAssignBitwiseXor(n)
-	case *assign.Coalesce:
-		p.printAssignCoalesce(n)
-	case *assign.Concat:
-		p.printAssignConcat(n)
-	case *assign.Div:
-		p.printAssignDiv(n)
-	case *assign.Minus:
-		p.printAssignMinus(n)
-	case *assign.Mod:
-		p.printAssignMod(n)
-	case *assign.Mul:
-		p.printAssignMul(n)
-	case *assign.Plus:
-		p.printAssignPlus(n)
-	case *assign.Pow:
-		p.printAssignPow(n)
-	case *assign.ShiftLeft:
-		p.printAssignShiftLeft(n)
-	case *assign.ShiftRight:
-		p.printAssignShiftRight(n)
-
-	// binary
-
-	case *binary.BitwiseAnd:
-		p.printBinaryBitwiseAnd(n)
-	case *binary.BitwiseOr:
-		p.printBinaryBitwiseOr(n)
-	case *binary.BitwiseXor:
-		p.printBinaryBitwiseXor(n)
-	case *binary.BooleanAnd:
-		p.printBinaryBooleanAnd(n)
-	case *binary.BooleanOr:
-		p.printBinaryBooleanOr(n)
-	case *binary.Coalesce:
-		p.printBinaryCoalesce(n)
-	case *binary.Concat:
-		p.printBinaryConcat(n)
-	case *binary.Div:
-		p.printBinaryDiv(n)
-	case *binary.Equal:
-		p.printBinaryEqual(n)
-	case *binary.GreaterOrEqual:
-		p.printBinaryGreaterOrEqual(n)
-	case *binary.Greater:
-		p.printBinaryGreater(n)
-	case *binary.Identical:
-		p.printBinaryIdentical(n)
-	case *binary.LogicalAnd:
-		p.printBinaryLogicalAnd(n)
-	case *binary.LogicalOr:
-		p.printBinaryLogicalOr(n)
-	case *binary.LogicalXor:
-		p.printBinaryLogicalXor(n)
-	case *binary.Minus:
-		p.printBinaryMinus(n)
-	case *binary.Mod:
-		p.printBinaryMod(n)
-	case *binary.Mul:
-		p.printBinaryMul(n)
-	case *binary.NotEqual:
-		p.printBinaryNotEqual(n)
-	case *binary.NotIdentical:
-		p.printBinaryNotIdentical(n)
-	case *binary.Plus:
-		p.printBinaryPlus(n)
-	case *binary.Pow:
-		p.printBinaryPow(n)
-	case *binary.ShiftLeft:
-		p.printBinaryShiftLeft(n)
-	case *binary.ShiftRight:
-		p.printBinaryShiftRight(n)
-	case *binary.SmallerOrEqual:
-		p.printBinarySmallerOrEqual(n)
-	case *binary.Smaller:
-		p.printBinarySmaller(n)
-	case *binary.Spaceship:
-		p.printBinarySpaceship(n)
-
-	// cast
-
-	case *cast.Array:
-		p.printArray(n)
-	case *cast.Bool:
-		p.printBool(n)
-	case *cast.Double:
-		p.printDouble(n)
-	case *cast.Int:
-		p.printInt(n)
-	case *cast.Object:
-		p.printObject(n)
-	case *cast.String:
-		p.printString(n)
-	case *cast.Unset:
-		p.printUnset(n)
-
-	// expr
-
-	case *expr.ArrayDimFetch:
-		p.printExprArrayDimFetch(n)
-	case *expr.ArrayItem:
-		p.printExprArrayItem(n)
-	case *expr.Array:
-		p.printExprArray(n)
-	case *expr.ArrowFunction:
-		p.printExprArrowFunction(n)
-	case *expr.BitwiseNot:
-		p.printExprBitwiseNot(n)
-	case *expr.BooleanNot:
-		p.printExprBooleanNot(n)
-	case *expr.ClassConstFetch:
-		p.printExprClassConstFetch(n)
-	case *expr.Clone:
-		p.printExprClone(n)
-	case *expr.ClosureUse:
-		p.printExprClosureUse(n)
-	case *expr.Closure:
-		p.printExprClosure(n)
-	case *expr.ConstFetch:
-		p.printExprConstFetch(n)
-	case *expr.Empty:
-		p.printExprEmpty(n)
-	case *expr.ErrorSuppress:
-		p.printExprErrorSuppress(n)
-	case *expr.Eval:
-		p.printExprEval(n)
-	case *expr.Exit:
-		p.printExprExit(n)
-	case *expr.FunctionCall:
-		p.printExprFunctionCall(n)
-	case *expr.Include:
-		p.printExprInclude(n)
-	case *expr.IncludeOnce:
-		p.printExprIncludeOnce(n)
-	case *expr.InstanceOf:
-		p.printExprInstanceOf(n)
-	case *expr.Isset:
-		p.printExprIsset(n)
-	case *expr.List:
-		p.printExprList(n)
-	case *expr.MethodCall:
-		p.printExprMethodCall(n)
-	case *expr.New:
-		p.printExprNew(n)
-	case *expr.PostDec:
-		p.printExprPostDec(n)
-	case *expr.PostInc:
-		p.printExprPostInc(n)
-	case *expr.PreDec:
-		p.printExprPreDec(n)
-	case *expr.PreInc:
-		p.printExprPreInc(n)
-	case *expr.Print:
-		p.printExprPrint(n)
-	case *expr.PropertyFetch:
-		p.printExprPropertyFetch(n)
-	case *expr.Reference:
-		p.printExprReference(n)
-	case *expr.Require:
-		p.printExprRequire(n)
-	case *expr.RequireOnce:
-		p.printExprRequireOnce(n)
-	case *expr.ShellExec:
-		p.printExprShellExec(n)
-	case *expr.ShortArray:
-		p.printExprShortArray(n)
-	case *expr.ShortList:
-		p.printExprShortList(n)
-	case *expr.StaticCall:
-		p.printExprStaticCall(n)
-	case *expr.StaticPropertyFetch:
-		p.printExprStaticPropertyFetch(n)
-	case *expr.Ternary:
-		p.printExprTernary(n)
-	case *expr.UnaryMinus:
-		p.printExprUnaryMinus(n)
-	case *expr.UnaryPlus:
-		p.printExprUnaryPlus(n)
-	case *expr.Variable:
-		p.printExprVariable(n)
-	case *expr.YieldFrom:
-		p.printExprYieldFrom(n)
-	case *expr.Yield:
-		p.printExprYield(n)
-
-	// stmt
-
-	case *stmt.AltElseIf:
-		p.printStmtAltElseIf(n)
-	case *stmt.AltElse:
-		p.printStmtAltElse(n)
-	case *stmt.AltFor:
-		p.printStmtAltFor(n)
-	case *stmt.AltForeach:
-		p.printStmtAltForeach(n)
-	case *stmt.AltIf:
-		p.printStmtAltIf(n)
-	case *stmt.AltSwitch:
-		p.printStmtAltSwitch(n)
-	case *stmt.AltWhile:
-		p.printStmtAltWhile(n)
-	case *stmt.Break:
-		p.printStmtBreak(n)
-	case *stmt.Case:
-		p.printStmtCase(n)
-	case *stmt.Catch:
-		p.printStmtCatch(n)
-	case *stmt.ClassMethod:
-		p.printStmtClassMethod(n)
-	case *stmt.Class:
-		p.printStmtClass(n)
-	case *stmt.ClassConstList:
-		p.printStmtClassConstList(n)
-	case *stmt.ConstList:
-		p.printStmtConstList(n)
-	case *stmt.Constant:
-		p.printStmtConstant(n)
-	case *stmt.Continue:
-		p.printStmtContinue(n)
-	case *stmt.Declare:
-		p.printStmtDeclare(n)
-	case *stmt.Default:
-		p.printStmtDefault(n)
-	case *stmt.Do:
-		p.printStmtDo(n)
-	case *stmt.Echo:
-		p.printStmtEcho(n)
-	case *stmt.ElseIf:
-		p.printStmtElseif(n)
-	case *stmt.Else:
-		p.printStmtElse(n)
-	case *stmt.Expression:
-		p.printStmtExpression(n)
-	case *stmt.Finally:
-		p.printStmtFinally(n)
-	case *stmt.For:
-		p.printStmtFor(n)
-	case *stmt.Foreach:
-		p.printStmtForeach(n)
-	case *stmt.Function:
-		p.printStmtFunction(n)
-	case *stmt.Global:
-		p.printStmtGlobal(n)
-	case *stmt.Goto:
-		p.printStmtGoto(n)
-	case *stmt.GroupUse:
-		p.printStmtGroupUse(n)
-	case *stmt.HaltCompiler:
-		p.printStmtHaltCompiler(n)
-	case *stmt.If:
-		p.printStmtIf(n)
-	case *stmt.InlineHtml:
-		p.printStmtInlineHTML(n)
-	case *stmt.Interface:
-		p.printStmtInterface(n)
-	case *stmt.Label:
-		p.printStmtLabel(n)
-	case *stmt.Namespace:
-		p.printStmtNamespace(n)
-	case *stmt.Nop:
-		p.printStmtNop(n)
-	case *stmt.PropertyList:
-		p.printStmtPropertyList(n)
-	case *stmt.Property:
-		p.printStmtProperty(n)
-	case *stmt.Return:
-		p.printStmtReturn(n)
-	case *stmt.StaticVar:
-		p.printStmtStaticVar(n)
-	case *stmt.Static:
-		p.printStmtStatic(n)
-	case *stmt.StmtList:
-		p.printStmtStmtList(n)
-	case *stmt.Switch:
-		p.printStmtSwitch(n)
-	case *stmt.Throw:
-		p.printStmtThrow(n)
-	case *stmt.TraitAdaptationList:
-		p.printStmtTraitAdaptationList(n)
-	case *stmt.TraitMethodRef:
-		p.printStmtTraitMethodRef(n)
-	case *stmt.TraitUseAlias:
-		p.printStmtTraitUseAlias(n)
-	case *stmt.TraitUsePrecedence:
-		p.printStmtTraitUsePrecedence(n)
-	case *stmt.TraitUse:
-		p.printStmtTraitUse(n)
-	case *stmt.Trait:
-		p.printStmtTrait(n)
-	case *stmt.Try:
-		p.printStmtTry(n)
-	case *stmt.Unset:
-		p.printStmtUnset(n)
-	case *stmt.UseList:
-		p.printStmtUseList(n)
-	case *stmt.Use:
-		p.printStmtUse(n)
-	case *stmt.While:
-		p.printStmtWhile(n)
-	}
-}
-
-// node
-
-func (p *Printer) printNodeRoot(n node.Node) {
-	nn := n.(*node.Root)
-	p.SetState(HtmlState)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeIdentifier(n node.Node) {
-	nn := n.(*node.Identifier)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, nn.Value)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeParameter(n node.Node) {
-	nn := n.(*node.Parameter)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.VariableType != nil {
-		p.Print(nn.VariableType)
-	}
-	p.printFreeFloating(nn, freefloating.OptionalType)
-
-	if nn.ByRef {
-		io.WriteString(p.w, "&")
-	}
-	p.printFreeFloating(nn, freefloating.Ampersand)
-
-	if nn.Variadic {
-		io.WriteString(p.w, "...")
-	}
-	p.printFreeFloating(nn, freefloating.Variadic)
-
-	p.Print(nn.Variable)
-
-	if nn.DefaultValue != nil {
-		p.printFreeFloating(nn, freefloating.Var)
-		io.WriteString(p.w, "=")
-		p.Print(nn.DefaultValue)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeNullable(n node.Node) {
-	nn := n.(*node.Nullable)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "?")
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeArgument(n node.Node) {
-	nn := n.(*node.Argument)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.IsReference {
-		io.WriteString(p.w, "&")
-	}
-	p.printFreeFloating(nn, freefloating.Ampersand)
-
-	if nn.Variadic {
-		io.WriteString(p.w, "...")
-	}
-	p.printFreeFloating(nn, freefloating.Variadic)
-
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// name
-
-func (p *Printer) printNameNamePart(n node.Node) {
-	nn := n.(*name.NamePart)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, nn.Value)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNameName(n node.Node) {
-	nn := n.(*name.Name)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.joinPrint("\\", nn.Parts)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNameFullyQualified(n node.Node) {
-	nn := n.(*name.FullyQualified)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "\\")
-	p.joinPrint("\\", nn.Parts)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNameRelative(n node.Node) {
-	nn := n.(*name.Relative)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "namespace")
-	p.printFreeFloating(nn, freefloating.Namespace)
-
-	for _, part := range nn.Parts {
-		io.WriteString(p.w, "\\")
-		p.Print(part)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// scalar
-
-func (p *Printer) printScalarLNumber(n node.Node) {
-	nn := n.(*scalar.Lnumber)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, nn.Value)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarDNumber(n node.Node) {
-	nn := n.(*scalar.Dnumber)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, nn.Value)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarString(n node.Node) {
-	nn := n.(*scalar.String)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, nn.Value)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarEncapsedStringPart(n node.Node) {
-	nn := n.(*scalar.EncapsedStringPart)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, nn.Value)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarEncapsed(n node.Node) {
-	nn := n.(*scalar.Encapsed)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "\"")
-	for _, part := range nn.Parts {
-		switch part.(type) {
-		case *expr.ArrayDimFetch:
-			s := (*part.GetFreeFloating())[freefloating.Start]
-			if len(s) > 0 && s[0].Value == "${" {
-				p.printExprArrayDimFetchWithoutLeadingDollar(part)
-			} else {
-				p.Print(part)
-			}
-		case *expr.Variable:
-			s := (*part.GetFreeFloating())[freefloating.Start]
-			if len(s) > 0 && s[0].Value == "${" {
-				p.printExprVariableWithoutLeadingDollar(part)
-			} else {
-				p.Print(part)
-			}
-		default:
-			p.Print(part)
-		}
-	}
-	io.WriteString(p.w, "\"")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarHeredoc(n node.Node) {
-	nn := n.(*scalar.Heredoc)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, nn.Label)
-
-	for _, part := range nn.Parts {
-		switch part.(type) {
-		case *expr.ArrayDimFetch:
-			s := (*part.GetFreeFloating())[freefloating.Start]
-			if len(s) > 0 && s[0].Value == "${" {
-				p.printExprArrayDimFetchWithoutLeadingDollar(part)
-			} else {
-				p.Print(part)
-			}
-		case *expr.Variable:
-			s := (*part.GetFreeFloating())[freefloating.Start]
-			if len(s) > 0 && s[0].Value == "${" {
-				p.printExprVariableWithoutLeadingDollar(part)
-			} else {
-				p.Print(part)
-			}
-		default:
-			p.Print(part)
-		}
-	}
-
-	io.WriteString(p.w, strings.Trim(nn.Label, "<\"'\n"))
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarMagicConstant(n node.Node) {
-	nn := n.(*scalar.MagicConstant)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, nn.Value)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// Assign
-
-func (p *Printer) printAssign(n node.Node) {
-	nn := n.(*assign.Assign)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignReference(n node.Node) {
-	nn := n.(*assign.Reference)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "=")
-	p.printFreeFloating(nn, freefloating.Equal)
-	io.WriteString(p.w, "&")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignBitwiseAnd(n node.Node) {
-	nn := n.(*assign.BitwiseAnd)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "&")
-	io.WriteString(p.w, "=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignBitwiseOr(n node.Node) {
-	nn := n.(*assign.BitwiseOr)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "|=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignBitwiseXor(n node.Node) {
-	nn := n.(*assign.BitwiseXor)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "^=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignCoalesce(n node.Node) {
-	nn := n.(*assign.Coalesce)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "??=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignConcat(n node.Node) {
-	nn := n.(*assign.Concat)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, ".=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignDiv(n node.Node) {
-	nn := n.(*assign.Div)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "/=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignMinus(n node.Node) {
-	nn := n.(*assign.Minus)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "-=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignMod(n node.Node) {
-	nn := n.(*assign.Mod)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "%=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignMul(n node.Node) {
-	nn := n.(*assign.Mul)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "*=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignPlus(n node.Node) {
-	nn := n.(*assign.Plus)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "+=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignPow(n node.Node) {
-	nn := n.(*assign.Pow)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "**=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignShiftLeft(n node.Node) {
-	nn := n.(*assign.ShiftLeft)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "<<=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignShiftRight(n node.Node) {
-	nn := n.(*assign.ShiftRight)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, ">>=")
-	p.Print(nn.Expression)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// binary
-
-func (p *Printer) printBinaryBitwiseAnd(n node.Node) {
-	nn := n.(*binary.BitwiseAnd)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "&")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBitwiseOr(n node.Node) {
-	nn := n.(*binary.BitwiseOr)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "|")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBitwiseXor(n node.Node) {
-	nn := n.(*binary.BitwiseXor)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "^")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBooleanAnd(n node.Node) {
-	nn := n.(*binary.BooleanAnd)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "&&")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBooleanOr(n node.Node) {
-	nn := n.(*binary.BooleanOr)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "||")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryCoalesce(n node.Node) {
-	nn := n.(*binary.Coalesce)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "??")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryConcat(n node.Node) {
-	nn := n.(*binary.Concat)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ".")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryDiv(n node.Node) {
-	nn := n.(*binary.Div)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "/")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryEqual(n node.Node) {
-	nn := n.(*binary.Equal)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "==")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryGreaterOrEqual(n node.Node) {
-	nn := n.(*binary.GreaterOrEqual)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ">=")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryGreater(n node.Node) {
-	nn := n.(*binary.Greater)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ">")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryIdentical(n node.Node) {
-	nn := n.(*binary.Identical)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "===")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryLogicalAnd(n node.Node) {
-	nn := n.(*binary.LogicalAnd)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	io.WriteString(p.w, "and")
-	if nn.Right.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryLogicalOr(n node.Node) {
-	nn := n.(*binary.LogicalOr)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	io.WriteString(p.w, "or")
-	if nn.Right.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryLogicalXor(n node.Node) {
-	nn := n.(*binary.LogicalXor)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	io.WriteString(p.w, "xor")
-	if nn.Right.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryMinus(n node.Node) {
-	nn := n.(*binary.Minus)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "-")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryMod(n node.Node) {
-	nn := n.(*binary.Mod)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "%")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryMul(n node.Node) {
-	nn := n.(*binary.Mul)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "*")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryNotEqual(n node.Node) {
-	nn := n.(*binary.NotEqual)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	p.printFreeFloating(nn, freefloating.Equal)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "!=")
-	}
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryNotIdentical(n node.Node) {
-	nn := n.(*binary.NotIdentical)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "!==")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryPlus(n node.Node) {
-	nn := n.(*binary.Plus)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "+")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryPow(n node.Node) {
-	nn := n.(*binary.Pow)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "**")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryShiftLeft(n node.Node) {
-	nn := n.(*binary.ShiftLeft)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "<<")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryShiftRight(n node.Node) {
-	nn := n.(*binary.ShiftRight)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ">>")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinarySmallerOrEqual(n node.Node) {
-	nn := n.(*binary.SmallerOrEqual)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "<=")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinarySmaller(n node.Node) {
-	nn := n.(*binary.Smaller)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "<")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinarySpaceship(n node.Node) {
-	nn := n.(*binary.Spaceship)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Left)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, "<=>")
-	p.Print(nn.Right)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// cast
-
-func (p *Printer) printArray(n node.Node) {
-	nn := n.(*cast.Array)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(array)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBool(n node.Node) {
-	nn := n.(*cast.Bool)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(boolean)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printDouble(n node.Node) {
-	nn := n.(*cast.Double)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(float)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printInt(n node.Node) {
-	nn := n.(*cast.Int)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(integer)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printObject(n node.Node) {
-	nn := n.(*cast.Object)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(object)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printString(n node.Node) {
-	nn := n.(*cast.String)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(string)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printUnset(n node.Node) {
-	nn := n.(*cast.Unset)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Cast)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "(unset)")
-	}
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// expr
-
-func (p *Printer) printExprArrayDimFetch(n node.Node) {
-	nn := n.(*expr.ArrayDimFetch)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "[")
-	}
-	p.Print(nn.Dim)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "]")
-	}
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArrayDimFetchWithoutLeadingDollar(n node.Node) {
-	nn := n.(*expr.ArrayDimFetch)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.printExprVariableWithoutLeadingDollar(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "[")
-	}
-	p.Print(nn.Dim)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "]")
-	}
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArrayItem(n node.Node) {
-	nn := n.(*expr.ArrayItem)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Unpack {
-		io.WriteString(p.w, "...")
-	}
-
-	if nn.Key != nil {
-		p.Print(nn.Key)
-		p.printFreeFloating(nn, freefloating.Expr)
-		io.WriteString(p.w, "=>")
-	}
-
-	p.Print(nn.Val)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArray(n node.Node) {
-	nn := n.(*expr.Array)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "array")
-	p.printFreeFloating(nn, freefloating.Array)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Items)
-	p.printFreeFloating(nn, freefloating.ArrayPairList)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArrowFunction(n node.Node) {
-	nn := n.(*expr.ArrowFunction)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Static {
-		io.WriteString(p.w, "static")
-	}
-	p.printFreeFloating(nn, freefloating.Static)
-	if nn.Static && n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	io.WriteString(p.w, "fn")
-	p.printFreeFloating(nn, freefloating.Function)
-
-	if nn.ReturnsRef {
-		io.WriteString(p.w, "&")
-	}
-	p.printFreeFloating(nn, freefloating.Ampersand)
-
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, freefloating.ParameterList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Params)
-
-	if nn.ReturnType != nil {
-		io.WriteString(p.w, ":")
-		p.Print(nn.ReturnType)
-	}
-	p.printFreeFloating(nn, freefloating.ReturnType)
-
-	io.WriteString(p.w, "=>")
-
-	p.printNode(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprBitwiseNot(n node.Node) {
-	nn := n.(*expr.BitwiseNot)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "~")
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprBooleanNot(n node.Node) {
-	nn := n.(*expr.BooleanNot)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "!")
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClassConstFetch(n node.Node) {
-	nn := n.(*expr.ClassConstFetch)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Class)
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "::")
-	p.Print(nn.ConstantName)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClone(n node.Node) {
-	nn := n.(*expr.Clone)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "clone")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClosureUse(n node.Node) {
-	nn := n.(*expr.ClosureUse)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "use")
-	p.printFreeFloating(nn, freefloating.Use)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Uses)
-	p.printFreeFloating(nn, freefloating.LexicalVarList)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClosure(n node.Node) {
-	nn := n.(*expr.Closure)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Static {
-		io.WriteString(p.w, "static")
-	}
-	p.printFreeFloating(nn, freefloating.Static)
-	if nn.Static && n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	io.WriteString(p.w, "function")
-	p.printFreeFloating(nn, freefloating.Function)
-
-	if nn.ReturnsRef {
-		io.WriteString(p.w, "&")
-	}
-	p.printFreeFloating(nn, freefloating.Ampersand)
-
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, freefloating.ParameterList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Params)
-
-	if nn.ClosureUse != nil {
-		p.Print(nn.ClosureUse)
-	}
-	p.printFreeFloating(nn, freefloating.LexicalVars)
-
-	if nn.ReturnType != nil {
-		io.WriteString(p.w, ":")
-		p.Print(nn.ReturnType)
-	}
-	p.printFreeFloating(nn, freefloating.ReturnType)
-
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprConstFetch(n node.Node) {
-	nn := n.(*expr.ConstFetch)
-	p.printFreeFloating(nn, freefloating.Start)
-	p.Print(nn.Constant)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprEmpty(n node.Node) {
-	nn := n.(*expr.Empty)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "empty")
-	p.printFreeFloating(nn, freefloating.Empty)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprErrorSuppress(n node.Node) {
-	nn := n.(*expr.ErrorSuppress)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "@")
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprEval(n node.Node) {
-	nn := n.(*expr.Eval)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "eval")
-	p.printFreeFloating(nn, freefloating.Eval)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprExit(n node.Node) {
-	nn := n.(*expr.Exit)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Die {
-		io.WriteString(p.w, "die")
-	} else {
-		io.WriteString(p.w, "exit")
-	}
-	p.printFreeFloating(nn, freefloating.Exit)
-
-	if nn.Expr != nil && nn.Expr.GetFreeFloating().IsEmpty() && nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprFunctionCall(n node.Node) {
-	nn := n.(*expr.FunctionCall)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Function)
-
-	p.printFreeFloating(nn.ArgumentList, freefloating.Start)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.ArgumentList.Arguments)
-	p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn.ArgumentList, freefloating.End)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprInclude(n node.Node) {
-	nn := n.(*expr.Include)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "include")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprIncludeOnce(n node.Node) {
-	nn := n.(*expr.IncludeOnce)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "include_once")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprInstanceOf(n node.Node) {
-	nn := n.(*expr.InstanceOf)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	io.WriteString(p.w, "instanceof")
-
-	if nn.Class.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Class)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprIsset(n node.Node) {
-	nn := n.(*expr.Isset)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "isset")
-	p.printFreeFloating(nn, freefloating.Isset)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Variables)
-	p.printFreeFloating(nn, freefloating.VarList)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprList(n node.Node) {
-	nn := n.(*expr.List)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "list")
-	p.printFreeFloating(nn, freefloating.List)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Items)
-	p.printFreeFloating(nn, freefloating.ArrayPairList)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprMethodCall(n node.Node) {
-	nn := n.(*expr.MethodCall)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "->")
-	p.Print(nn.Method)
-
-	p.printFreeFloating(nn.ArgumentList, freefloating.Start)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.ArgumentList.Arguments)
-	p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn.ArgumentList, freefloating.End)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprNew(n node.Node) {
-	nn := n.(*expr.New)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "new")
-	if nn.Class.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Class)
-
-	if nn.ArgumentList != nil {
-		p.printFreeFloating(nn.ArgumentList, freefloating.Start)
-		io.WriteString(p.w, "(")
-		p.joinPrint(",", nn.ArgumentList.Arguments)
-		p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
-		io.WriteString(p.w, ")")
-		p.printFreeFloating(nn.ArgumentList, freefloating.End)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPostDec(n node.Node) {
-	nn := n.(*expr.PostDec)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "--")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPostInc(n node.Node) {
-	nn := n.(*expr.PostInc)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "++")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPreDec(n node.Node) {
-	nn := n.(*expr.PreDec)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "--")
-	p.Print(nn.Variable)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPreInc(n node.Node) {
-	nn := n.(*expr.PreInc)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "++")
-	p.Print(nn.Variable)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPrint(n node.Node) {
-	nn := n.(*expr.Print)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "print")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPropertyFetch(n node.Node) {
-	nn := n.(*expr.PropertyFetch)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, "->")
-	p.Print(nn.Property)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprReference(n node.Node) {
-	nn := n.(*expr.Reference)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "&")
-	p.Print(nn.Variable)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprRequire(n node.Node) {
-	nn := n.(*expr.Require)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "require")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprRequireOnce(n node.Node) {
-	nn := n.(*expr.RequireOnce)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "require_once")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprShellExec(n node.Node) {
-	nn := n.(*expr.ShellExec)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "`")
-	p.joinPrint("", nn.Parts)
-	io.WriteString(p.w, "`")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprShortArray(n node.Node) {
-	nn := n.(*expr.ShortArray)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "[")
-	p.joinPrint(",", nn.Items)
-	p.printFreeFloating(nn, freefloating.ArrayPairList)
-	io.WriteString(p.w, "]")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprShortList(n node.Node) {
-	nn := n.(*expr.ShortList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "[")
-	p.joinPrint(",", nn.Items)
-	p.printFreeFloating(nn, freefloating.ArrayPairList)
-	io.WriteString(p.w, "]")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprStaticCall(n node.Node) {
-	nn := n.(*expr.StaticCall)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Class)
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "::")
-	p.Print(nn.Call)
-
-	p.printFreeFloating(nn.ArgumentList, freefloating.Start)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.ArgumentList.Arguments)
-	p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn.ArgumentList, freefloating.End)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprStaticPropertyFetch(n node.Node) {
-	nn := n.(*expr.StaticPropertyFetch)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Class)
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "::")
-	p.Print(nn.Property)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprTernary(n node.Node) {
-	nn := n.(*expr.Ternary)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Condition)
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, "?")
-
-	if nn.IfTrue != nil {
-		p.Print(nn.IfTrue)
-	}
-	p.printFreeFloating(nn, freefloating.True)
-
-	io.WriteString(p.w, ":")
-	p.Print(nn.IfFalse)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprUnaryMinus(n node.Node) {
-	nn := n.(*expr.UnaryMinus)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "-")
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprUnaryPlus(n node.Node) {
-	nn := n.(*expr.UnaryPlus)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "+")
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprVariable(n node.Node) {
-	nn := n.(*expr.Variable)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.printFreeFloating(nn, freefloating.Dollar)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "$")
-	}
-
-	p.Print(nn.VarName)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprVariableWithoutLeadingDollar(n node.Node) {
-	nn := n.(*expr.Variable)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.VarName)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprYieldFrom(n node.Node) {
-	nn := n.(*expr.YieldFrom)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "yield from")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprYield(n node.Node) {
-	nn := n.(*expr.Yield)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "yield")
-
-	if nn.Key != nil {
-		if nn.Key.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Key)
-		p.printFreeFloating(nn, freefloating.Expr)
-		io.WriteString(p.w, "=>")
-	} else {
-		if nn.Value.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.Print(nn.Value)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-// smtm
-
-func (p *Printer) printStmtAltElseIf(n node.Node) {
-	nn := n.(*stmt.AltElseIf)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "elseif")
-	p.printFreeFloating(nn, freefloating.ElseIf)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, ":")
-
-	if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
-		p.printNodes(s)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltElse(n node.Node) {
-	nn := n.(*stmt.AltElse)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "else")
-	p.printFreeFloating(nn, freefloating.Else)
-	io.WriteString(p.w, ":")
-
-	if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
-		p.printNodes(s)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltFor(n node.Node) {
-	nn := n.(*stmt.AltFor)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "for")
-	p.printFreeFloating(nn, freefloating.For)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Init)
-	p.printFreeFloating(nn, freefloating.InitExpr)
-	io.WriteString(p.w, ";")
-	p.joinPrint(",", nn.Cond)
-	p.printFreeFloating(nn, freefloating.CondExpr)
-	io.WriteString(p.w, ";")
-	p.joinPrint(",", nn.Loop)
-	p.printFreeFloating(nn, freefloating.IncExpr)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, ":")
-
-	s := nn.Stmt.(*stmt.StmtList)
-	p.printNodes(s.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-
-	io.WriteString(p.w, "endfor")
-	p.printFreeFloating(nn, freefloating.AltEnd)
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltForeach(n node.Node) {
-	nn := n.(*stmt.AltForeach)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "foreach")
-	p.printFreeFloating(nn, freefloating.Foreach)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	io.WriteString(p.w, "as")
-
-	if nn.Key != nil {
-		if nn.Key.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Key)
-		p.printFreeFloating(nn, freefloating.Key)
-		io.WriteString(p.w, "=>")
-	} else {
-		if nn.Variable.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-
-	io.WriteString(p.w, ":")
-	s := nn.Stmt.(*stmt.StmtList)
-	p.printNodes(s.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-
-	io.WriteString(p.w, "endforeach")
-	p.printFreeFloating(nn, freefloating.AltEnd)
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltIf(n node.Node) {
-	nn := n.(*stmt.AltIf)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "if")
-	p.printFreeFloating(nn, freefloating.If)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, ":")
-
-	s := nn.Stmt.(*stmt.StmtList)
-	p.printNodes(s.Stmts)
-
-	for _, elseif := range nn.ElseIf {
-		p.Print(elseif)
-	}
-
-	if nn.Else != nil {
-		p.Print(nn.Else)
-	}
-
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "endif")
-	p.printFreeFloating(nn, freefloating.AltEnd)
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltSwitch(n node.Node) {
-	nn := n.(*stmt.AltSwitch)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "switch")
-	p.printFreeFloating(nn, freefloating.Switch)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, ":")
-
-	p.printFreeFloating(nn.CaseList, freefloating.Start)
-	p.printFreeFloating(nn.CaseList, freefloating.CaseListStart)
-	p.printNodes(nn.CaseList.Cases)
-	p.printFreeFloating(nn.CaseList, freefloating.CaseListEnd)
-	p.printFreeFloating(nn.CaseList, freefloating.End)
-
-	io.WriteString(p.w, "endswitch")
-	p.printFreeFloating(nn, freefloating.AltEnd)
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltWhile(n node.Node) {
-	nn := n.(*stmt.AltWhile)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "while")
-	p.printFreeFloating(nn, freefloating.While)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, ":")
-
-	s := nn.Stmt.(*stmt.StmtList)
-	p.printNodes(s.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-
-	io.WriteString(p.w, "endwhile")
-	p.printFreeFloating(nn, freefloating.AltEnd)
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtBreak(n node.Node) {
-	nn := n.(*stmt.Break)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "break")
-	if nn.Expr != nil {
-		if nn.Expr.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Expr)
-	}
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtCase(n node.Node) {
-	nn := n.(*stmt.Case)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "case")
-	if nn.Cond.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	p.printFreeFloating(nn, freefloating.CaseSeparator)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ":")
-	}
-
-	if len(nn.Stmts) > 0 {
-		p.printNodes(nn.Stmts)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtCatch(n node.Node) {
-	nn := n.(*stmt.Catch)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "catch")
-	p.printFreeFloating(nn, freefloating.Catch)
-	io.WriteString(p.w, "(")
-	p.joinPrint("|", nn.Types)
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtClassMethod(n node.Node) {
-	nn := n.(*stmt.ClassMethod)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Modifiers != nil {
-		for k, m := range nn.Modifiers {
-			if k > 0 && m.GetFreeFloating().IsEmpty() {
-				io.WriteString(p.w, " ")
-			}
-			p.Print(m)
-		}
-
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-	p.printFreeFloating(nn, freefloating.ModifierList)
-	io.WriteString(p.w, "function")
-	p.printFreeFloating(nn, freefloating.Function)
-
-	if nn.ReturnsRef {
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		io.WriteString(p.w, "&")
-		p.printFreeFloating(nn, freefloating.Ampersand)
-	} else {
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.Print(nn.MethodName)
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, freefloating.ParameterList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Params)
-
-	if nn.ReturnType != nil {
-		io.WriteString(p.w, ":")
-		p.Print(nn.ReturnType)
-	}
-
-	p.Print(nn.Stmt)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtClass(n node.Node) {
-	nn := n.(*stmt.Class)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Modifiers != nil {
-		for k, m := range nn.Modifiers {
-			if k > 0 && m.GetFreeFloating().IsEmpty() {
-				io.WriteString(p.w, " ")
-			}
-			p.Print(m)
-		}
-
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-	p.printFreeFloating(nn, freefloating.ModifierList)
-	io.WriteString(p.w, "class")
-	p.printFreeFloating(nn, freefloating.Class)
-
-	if nn.ClassName != nil {
-		if nn.ClassName.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.ClassName)
-	}
-
-	if nn.ArgumentList != nil {
-		p.printFreeFloating(nn.ArgumentList, freefloating.Start)
-		io.WriteString(p.w, "(")
-		p.joinPrint(",", nn.ArgumentList.Arguments)
-		p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
-		io.WriteString(p.w, ")")
-		p.printFreeFloating(nn.ArgumentList, freefloating.End)
-	}
-
-	if nn.Extends != nil {
-		p.printFreeFloating(nn.Extends, freefloating.Start)
-		if nn.Extends.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		io.WriteString(p.w, "extends")
-		if nn.Extends.ClassName.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Extends.ClassName)
-	}
-
-	if nn.Implements != nil {
-		p.printFreeFloating(nn.Implements, freefloating.Start)
-		if nn.Implements.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		io.WriteString(p.w, "implements")
-		if nn.Implements.InterfaceNames[0].GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.joinPrint(",", nn.Implements.InterfaceNames)
-	}
-
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtClassConstList(n node.Node) {
-	nn := n.(*stmt.ClassConstList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Modifiers != nil {
-		for k, m := range nn.Modifiers {
-			if k > 0 && m.GetFreeFloating().IsEmpty() {
-				io.WriteString(p.w, " ")
-			}
-			p.Print(m)
-		}
-
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-	p.printFreeFloating(nn, freefloating.ModifierList)
-	io.WriteString(p.w, "const")
-
-	if nn.Consts[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.joinPrint(",", nn.Consts)
-	p.printFreeFloating(nn, freefloating.ConstList)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtConstList(n node.Node) {
-	nn := n.(*stmt.ConstList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "const")
-
-	if nn.Consts[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.joinPrint(",", nn.Consts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtConstant(n node.Node) {
-	nn := n.(*stmt.Constant)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.ConstantName)
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "=")
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtContinue(n node.Node) {
-	nn := n.(*stmt.Continue)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "continue")
-
-	if nn.Expr != nil {
-		if nn.Expr.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Expr)
-	}
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtDeclare(n node.Node) {
-	nn := n.(*stmt.Declare)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "declare")
-	p.printFreeFloating(nn, freefloating.Declare)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Consts)
-	p.printFreeFloating(nn, freefloating.ConstList)
-	io.WriteString(p.w, ")")
-
-	if nn.Alt {
-		p.printFreeFloating(nn, freefloating.Cond)
-		io.WriteString(p.w, ":")
-
-		s := nn.Stmt.(*stmt.StmtList)
-		p.printNodes(s.Stmts)
-		p.printFreeFloating(nn, freefloating.Stmts)
-
-		io.WriteString(p.w, "enddeclare")
-		p.printFreeFloating(nn, freefloating.AltEnd)
-
-		p.printFreeFloating(nn, freefloating.SemiColon)
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, ";")
-		}
-	} else {
-		p.Print(nn.Stmt)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtDefault(n node.Node) {
-	nn := n.(*stmt.Default)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "default")
-	p.printFreeFloating(nn, freefloating.Default)
-	p.printFreeFloating(nn, freefloating.CaseSeparator)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ":")
-	}
-
-	if len(nn.Stmts) > 0 {
-		p.printNodes(nn.Stmts)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtDo(n node.Node) {
-	nn := n.(*stmt.Do)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "do")
-
-	if _, ok := nn.Stmt.(*stmt.StmtList); !ok {
-		if nn.Stmt.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.Print(nn.Stmt)
-	p.printFreeFloating(nn, freefloating.Stmts)
-
-	io.WriteString(p.w, "while")
-	p.printFreeFloating(nn, freefloating.While)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Cond)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtEcho(n node.Node) {
-	nn := n.(*stmt.Echo)
-
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "echo")
-	}
-	if nn.Exprs[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	p.printFreeFloating(nn, freefloating.Start)
-	p.printFreeFloating(nn, freefloating.Echo)
-
-	p.joinPrint(",", nn.Exprs)
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtElseif(n node.Node) {
-	nn := n.(*stmt.ElseIf)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "elseif")
-	p.printFreeFloating(nn, freefloating.ElseIf)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-
-	p.Print(nn.Stmt)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtElse(n node.Node) {
-	nn := n.(*stmt.Else)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "else")
-
-	if _, ok := nn.Stmt.(*stmt.StmtList); !ok {
-		if nn.Stmt.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.Print(nn.Stmt)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtExpression(n node.Node) {
-	nn := n.(*stmt.Expression)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtFinally(n node.Node) {
-	nn := n.(*stmt.Finally)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "finally")
-	p.printFreeFloating(nn, freefloating.Finally)
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtFor(n node.Node) {
-	nn := n.(*stmt.For)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "for")
-	p.printFreeFloating(nn, freefloating.For)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Init)
-	p.printFreeFloating(nn, freefloating.InitExpr)
-	io.WriteString(p.w, ";")
-	p.joinPrint(",", nn.Cond)
-	p.printFreeFloating(nn, freefloating.CondExpr)
-	io.WriteString(p.w, ";")
-	p.joinPrint(",", nn.Loop)
-	p.printFreeFloating(nn, freefloating.IncExpr)
-	io.WriteString(p.w, ")")
-
-	p.Print(nn.Stmt)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtForeach(n node.Node) {
-	nn := n.(*stmt.Foreach)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "foreach")
-	p.printFreeFloating(nn, freefloating.Foreach)
-	io.WriteString(p.w, "(")
-
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	io.WriteString(p.w, "as")
-
-	if nn.Key != nil {
-		if nn.Key.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Key)
-		p.printFreeFloating(nn, freefloating.Key)
-		io.WriteString(p.w, "=>")
-	} else {
-		if nn.Variable.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-	p.Print(nn.Variable)
-	p.printFreeFloating(nn, freefloating.Var)
-
-	io.WriteString(p.w, ")")
-
-	p.Print(nn.Stmt)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtFunction(n node.Node) {
-	nn := n.(*stmt.Function)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "function")
-	p.printFreeFloating(nn, freefloating.Function)
-
-	if nn.ReturnsRef {
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		io.WriteString(p.w, "&")
-	} else {
-		if nn.FunctionName.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.Print(nn.FunctionName)
-	p.printFreeFloating(nn, freefloating.Name)
-
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, freefloating.ParamList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.Params)
-
-	if nn.ReturnType != nil {
-		io.WriteString(p.w, ":")
-		p.Print(nn.ReturnType)
-	}
-	p.printFreeFloating(nn, freefloating.ReturnType)
-
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtGlobal(n node.Node) {
-	nn := n.(*stmt.Global)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "global")
-	p.joinPrint(",", nn.Vars)
-	p.printFreeFloating(nn, freefloating.VarList)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtGoto(n node.Node) {
-	nn := n.(*stmt.Goto)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "goto")
-	if nn.Label.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Label)
-	p.printFreeFloating(nn, freefloating.Label)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtGroupUse(n node.Node) {
-	nn := n.(*stmt.GroupUse)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "use")
-	p.printFreeFloating(nn, freefloating.Use)
-
-	if nn.UseType != nil {
-		if nn.UseType.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.UseType)
-	}
-
-	if nn.Prefix.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Prefix)
-	io.WriteString(p.w, "\\")
-	p.printFreeFloating(nn, freefloating.Slash)
-
-	io.WriteString(p.w, "{")
-	p.joinPrint(",", nn.UseList)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-	p.printFreeFloating(nn, freefloating.UseDeclarationList)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtHaltCompiler(n node.Node) {
-	nn := n.(*stmt.HaltCompiler)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "__halt_compiler")
-	p.printFreeFloating(nn, freefloating.HaltCompiller)
-	io.WriteString(p.w, "(")
-	p.printFreeFloating(nn, freefloating.OpenParenthesisToken)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.CloseParenthesisToken)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtIf(n node.Node) {
-	nn := n.(*stmt.If)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "if")
-	p.printFreeFloating(n, freefloating.If)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(n, freefloating.Expr)
-	io.WriteString(p.w, ")")
-
-	p.Print(nn.Stmt)
-
-	if nn.ElseIf != nil {
-		p.printNodes(nn.ElseIf)
-	}
-
-	if nn.Else != nil {
-		p.Print(nn.Else)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtInlineHTML(n node.Node) {
-	nn := n.(*stmt.InlineHtml)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if p.s == PhpState && nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, "?>")
-	}
-	p.SetState(HtmlState)
-
-	io.WriteString(p.w, nn.Value)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtInterface(n node.Node) {
-	nn := n.(*stmt.Interface)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "interface")
-
-	if nn.InterfaceName.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	p.Print(nn.InterfaceName)
-
-	if nn.Extends != nil {
-		p.printFreeFloating(nn.Extends, freefloating.Start)
-		if nn.Extends.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		io.WriteString(p.w, "extends")
-		if nn.Extends.InterfaceNames[0].GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.joinPrint(",", nn.Extends.InterfaceNames)
-	}
-
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtLabel(n node.Node) {
-	nn := n.(*stmt.Label)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.LabelName)
-	p.printFreeFloating(nn, freefloating.Label)
-
-	io.WriteString(p.w, ":")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtNamespace(n node.Node) {
-	nn := n.(*stmt.Namespace)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "namespace")
-
-	if nn.NamespaceName != nil {
-		if nn.NamespaceName.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.NamespaceName)
-	}
-
-	if nn.Stmts != nil {
-		p.printFreeFloating(nn, freefloating.Namespace)
-		io.WriteString(p.w, "{")
-		p.printNodes(nn.Stmts)
-		p.printFreeFloating(nn, freefloating.Stmts)
-		io.WriteString(p.w, "}")
-	} else {
-		p.printFreeFloating(nn, freefloating.SemiColon)
-		if nn.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, ";")
-		}
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtNop(n node.Node) {
-	p.printFreeFloating(n, freefloating.Start)
-	p.printFreeFloating(n, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-	p.printFreeFloating(n, freefloating.End)
-}
-
-func (p *Printer) printStmtPropertyList(n node.Node) {
-	nn := n.(*stmt.PropertyList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	for k, m := range nn.Modifiers {
-		if k > 0 && m.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(m)
-	}
-
-	if nn.Type != nil && nn.Type.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	p.Print(nn.Type)
-
-	if nn.Properties[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	p.joinPrint(",", nn.Properties)
-	p.printFreeFloating(n, freefloating.PropertyList)
-
-	p.printFreeFloating(n, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtProperty(n node.Node) {
-	nn := n.(*stmt.Property)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Variable)
-
-	if nn.Expr != nil {
-		p.printFreeFloating(nn, freefloating.Var)
-		io.WriteString(p.w, "=")
-		p.Print(nn.Expr)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtReturn(n node.Node) {
-	nn := n.(*stmt.Return)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "return")
-	if nn.Expr != nil && nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtStaticVar(n node.Node) {
-	nn := n.(*stmt.StaticVar)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Variable)
-
-	if nn.Expr != nil {
-		p.printFreeFloating(nn, freefloating.Var)
-		io.WriteString(p.w, "=")
-		p.Print(nn.Expr)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtStatic(n node.Node) {
-	nn := n.(*stmt.Static)
-	p.printFreeFloating(nn, freefloating.Start)
-	io.WriteString(p.w, "static")
-
-	p.joinPrint(",", nn.Vars)
-	p.printFreeFloating(nn, freefloating.VarList)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtStmtList(n node.Node) {
-	nn := n.(*stmt.StmtList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtSwitch(n node.Node) {
-	nn := n.(*stmt.Switch)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "switch")
-	p.printFreeFloating(nn, freefloating.Switch)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-
-	p.printFreeFloating(nn.CaseList, freefloating.Start)
-	io.WriteString(p.w, "{")
-	p.printFreeFloating(nn.CaseList, freefloating.CaseListStart)
-	p.printNodes(nn.CaseList.Cases)
-	p.printFreeFloating(nn.CaseList, freefloating.CaseListEnd)
-	io.WriteString(p.w, "}")
-	p.printFreeFloating(nn.CaseList, freefloating.End)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtThrow(n node.Node) {
-	nn := n.(*stmt.Throw)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "throw")
-	if nn.Expr.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.Expr)
-	p.printFreeFloating(nn, freefloating.Expr)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitAdaptationList(n node.Node) {
-	nn := n.(*stmt.TraitAdaptationList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Adaptations)
-	p.printFreeFloating(nn, freefloating.AdaptationList)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitMethodRef(n node.Node) {
-	nn := n.(*stmt.TraitMethodRef)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.Trait != nil {
-		p.Print(nn.Trait)
-		p.printFreeFloating(nn, freefloating.Name)
-		io.WriteString(p.w, "::")
-	}
-
-	p.Print(nn.Method)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitUseAlias(n node.Node) {
-	nn := n.(*stmt.TraitUseAlias)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Ref)
-	p.printFreeFloating(nn, freefloating.Ref)
-
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	io.WriteString(p.w, "as")
-
-	if nn.Modifier != nil {
-		if nn.Modifier.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Modifier)
-	}
-
-	if nn.Alias != nil {
-		if nn.Alias.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Alias)
-	}
-	p.printFreeFloating(nn, freefloating.Alias)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitUsePrecedence(n node.Node) {
-	nn := n.(*stmt.TraitUsePrecedence)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	p.Print(nn.Ref)
-	p.printFreeFloating(nn, freefloating.Ref)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-
-	io.WriteString(p.w, "insteadof")
-	if nn.Insteadof[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.joinPrint(",", nn.Insteadof)
-	p.printFreeFloating(nn, freefloating.NameList)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitUse(n node.Node) {
-	nn := n.(*stmt.TraitUse)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "use")
-	if nn.Traits[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.joinPrint(",", nn.Traits)
-
-	p.Print(nn.TraitAdaptationList)
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTrait(n node.Node) {
-	nn := n.(*stmt.Trait)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "trait")
-	if nn.TraitName.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.Print(nn.TraitName)
-
-	p.printFreeFloating(nn, freefloating.Name)
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTry(n node.Node) {
-	nn := n.(*stmt.Try)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "try")
-	p.printFreeFloating(nn, freefloating.Try)
-	io.WriteString(p.w, "{")
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, freefloating.Stmts)
-	io.WriteString(p.w, "}")
-
-	if nn.Catches != nil {
-		p.printNodes(nn.Catches)
-	}
-
-	if nn.Finally != nil {
-		p.Print(nn.Finally)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtUnset(n node.Node) {
-	nn := n.(*stmt.Unset)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "unset")
-	p.printFreeFloating(nn, freefloating.Unset)
-	io.WriteString(p.w, "(")
-	p.joinPrint(",", nn.Vars)
-	p.printFreeFloating(nn, freefloating.VarList)
-	io.WriteString(p.w, ")")
-	p.printFreeFloating(nn, freefloating.CloseParenthesisToken)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if n.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtUseList(n node.Node) {
-	nn := n.(*stmt.UseList)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "use")
-
-	if nn.UseType != nil {
-		if nn.UseType.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.UseType)
-	}
-
-	if nn.Uses[0].GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, " ")
-	}
-	p.joinPrint(",", nn.Uses)
-	p.printFreeFloating(nn, freefloating.UseDeclarationList)
-
-	p.printFreeFloating(nn, freefloating.SemiColon)
-	if nn.GetFreeFloating().IsEmpty() {
-		io.WriteString(p.w, ";")
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtUse(n node.Node) {
-	nn := n.(*stmt.Use)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	if nn.UseType != nil {
-		p.Print(nn.UseType)
-		if nn.UseType.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-	}
-
-	p.printFreeFloating(nn, freefloating.Slash)
-
-	p.Print(nn.Use)
-
-	if nn.Alias != nil {
-		if nn.Alias.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		io.WriteString(p.w, "as")
-		if nn.Alias.GetFreeFloating().IsEmpty() {
-			io.WriteString(p.w, " ")
-		}
-		p.Print(nn.Alias)
-	}
-
-	p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtWhile(n node.Node) {
-	nn := n.(*stmt.While)
-	p.printFreeFloating(nn, freefloating.Start)
-
-	io.WriteString(p.w, "while")
-	p.printFreeFloating(nn, freefloating.While)
-	io.WriteString(p.w, "(")
-	p.Print(nn.Cond)
-	p.printFreeFloating(nn, freefloating.Expr)
-	io.WriteString(p.w, ")")
-
-	p.Print(nn.Stmt)
-
-	p.printFreeFloating(nn, freefloating.End)
-}