diff --git a/internal/php5/php5.go b/internal/php5/php5.go
index 24fa23b..219f8fc 100644
Binary files a/internal/php5/php5.go and b/internal/php5/php5.go differ
diff --git a/internal/php5/php5.y b/internal/php5/php5.y
index f26e824..f244655 100644
--- a/internal/php5/php5.y
+++ b/internal/php5/php5.y
@@ -264,6 +264,8 @@ import (
 start:
         top_statement_list
             {
+                yylex.(*Parser).currentToken.Value = nil
+
                 yylex.(*Parser).rootNode = &ast.Root{
                     Position: yylex.(*Parser).builder.NewNodeListPosition($1),
                     Stmts:  $1,
@@ -934,7 +936,6 @@ unticked_statement:
             {
                 $2.(*ast.StmtGlobal).GlobalTkn = $1
                 $2.(*ast.StmtGlobal).SemiColonTkn = $3
-                $2.(*ast.StmtGlobal).SeparatorTkns = append($2.(*ast.StmtGlobal).SeparatorTkns, nil)
                 $2.(*ast.StmtGlobal).Position = yylex.(*Parser).builder.NewTokensPosition($1, $3)
 
                 $$ = $2
@@ -943,7 +944,6 @@ unticked_statement:
             {
                 $2.(*ast.StmtStatic).StaticTkn = $1
                 $2.(*ast.StmtStatic).SemiColonTkn = $3
-                $2.(*ast.StmtStatic).SeparatorTkns = append($2.(*ast.StmtStatic).SeparatorTkns, nil)
                 $2.(*ast.StmtStatic).Position = yylex.(*Parser).builder.NewTokensPosition($1, $3)
 
                 $$ = $2
@@ -1069,8 +1069,8 @@ unticked_statement:
                     GotoTkn: $1,
                     Label: &ast.Identifier{
                         Position: yylex.(*Parser).builder.NewTokenPosition($1),
-                        IdentifierTkn: $1,
-                        Value:         $1.Value,
+                        IdentifierTkn: $2,
+                        Value:         $2.Value,
                     },
                     SemiColonTkn: $3,
                 }
@@ -2197,9 +2197,9 @@ trait_adaptations:
             {
                 $$ = &ast.StmtTraitAdaptationList{
                     Position: yylex.(*Parser).builder.NewTokensPosition($1, $3),
-                    OpenParenthesisTkn:  $1,
-                    Adaptations:         $2,
-                    CloseParenthesisTkn: $3,
+                    OpenCurlyBracketTkn:  $1,
+                    Adaptations:          $2,
+                    CloseCurlyBracketTkn: $3,
                 }
             }
 ;
@@ -2691,7 +2691,7 @@ new_expr:
                         OpenParenthesisTkn:  $3.(*ast.ArgumentList).OpenParenthesisTkn,
                         Arguments:           $3.(*ast.ArgumentList).Arguments,
                         SeparatorTkns:       $3.(*ast.ArgumentList).SeparatorTkns,
-                        CloseParenthesisTkn: $3.(*ast.ArgumentList).OpenParenthesisTkn,
+                        CloseParenthesisTkn: $3.(*ast.ArgumentList).CloseParenthesisTkn,
                     }
                 } else {
                     $$ = &ast.ExprNew{
@@ -2749,7 +2749,7 @@ expr_without_variable:
                         OpenParenthesisTkn:  $6.(*ast.ArgumentList).OpenParenthesisTkn,
                         Arguments:           $6.(*ast.ArgumentList).Arguments,
                         SeparatorTkns:       $6.(*ast.ArgumentList).SeparatorTkns,
-                        CloseParenthesisTkn: $6.(*ast.ArgumentList).OpenParenthesisTkn,
+                        CloseParenthesisTkn: $6.(*ast.ArgumentList).CloseParenthesisTkn,
                     }
                 } else {
                     _new = &ast.ExprNew{
@@ -3620,7 +3620,7 @@ function_call:
                     OpenParenthesisTkn:  $2.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $2.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $2.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $2.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $2.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   T_NAMESPACE T_NS_SEPARATOR namespace_name function_call_parameter_list
@@ -3637,7 +3637,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   T_NS_SEPARATOR namespace_name function_call_parameter_list
@@ -3653,7 +3653,7 @@ function_call:
                     OpenParenthesisTkn:  $3.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $3.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $3.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $3.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $3.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   class_name T_PAAMAYIM_NEKUDOTAYIM variable_name function_call_parameter_list
@@ -3666,7 +3666,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects function_call_parameter_list
@@ -3679,7 +3679,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_name function_call_parameter_list
@@ -3692,7 +3692,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   variable_class_name T_PAAMAYIM_NEKUDOTAYIM variable_without_objects function_call_parameter_list
@@ -3705,7 +3705,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   variable_without_objects function_call_parameter_list
@@ -3716,7 +3716,7 @@ function_call:
                     OpenParenthesisTkn:  $2.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $2.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $2.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $2.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $2.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
 ;
@@ -4500,7 +4500,7 @@ scalar:
                     Position: yylex.(*Parser).builder.NewTokensPosition($1, $3),
                     OpenQoteTkn:  $1,
                     Parts:        $2,
-                    CloseQoteTkn: $1,
+                    CloseQoteTkn: $3,
                 }
             }
     |   T_START_HEREDOC encaps_list T_END_HEREDOC
@@ -4674,7 +4674,7 @@ variable:
                                     OpenParenthesisTkn:  mc.OpenParenthesisTkn,
                                     Arguments:           mc.Arguments,
                                     SeparatorTkns:       mc.SeparatorTkns,
-                                    CloseParenthesisTkn: mc.OpenParenthesisTkn,
+                                    CloseParenthesisTkn: mc.CloseParenthesisTkn,
                                 },
                             )
                             $3 = append($3, $4[1:len($4)]...)
diff --git a/internal/php7/php7.go b/internal/php7/php7.go
index 11c021e..7e9dd54 100644
Binary files a/internal/php7/php7.go and b/internal/php7/php7.go differ
diff --git a/internal/php7/php7.y b/internal/php7/php7.y
index 4f52bad..1db8b0a 100644
--- a/internal/php7/php7.y
+++ b/internal/php7/php7.y
@@ -281,6 +281,8 @@ import (
 start:
         top_statement_list
             {
+                yylex.(*Parser).currentToken.Value = nil
+
                 yylex.(*Parser).rootNode = &ast.Root{
                     Position: yylex.(*Parser).builder.NewNodeListPosition($1),
                     Stmts:  $1,
@@ -579,7 +581,9 @@ group_use_declaration:
 mixed_group_use_declaration:
         namespace_name T_NS_SEPARATOR '{' inline_use_declarations possible_comma '}'
             {
-                $4.(*ast.ParserSeparatedList).SeparatorTkns = append($4.(*ast.ParserSeparatedList).SeparatorTkns, $5)
+                if $5 != nil {
+                    $4.(*ast.ParserSeparatedList).SeparatorTkns = append($4.(*ast.ParserSeparatedList).SeparatorTkns, $5)
+                }
 
                 $$ = &ast.StmtGroupUse{
                     Position: yylex.(*Parser).builder.NewNodeListTokenPosition($1.(*ast.ParserSeparatedList).Items, $6),
@@ -597,7 +601,9 @@ mixed_group_use_declaration:
             }
     |   T_NS_SEPARATOR namespace_name T_NS_SEPARATOR '{' inline_use_declarations possible_comma '}'
             {
-                $5.(*ast.ParserSeparatedList).SeparatorTkns = append($5.(*ast.ParserSeparatedList).SeparatorTkns, $6)
+                if $6 != nil {
+                    $5.(*ast.ParserSeparatedList).SeparatorTkns = append($5.(*ast.ParserSeparatedList).SeparatorTkns, $6)
+                }
 
                 $$ = &ast.StmtGroupUse{
                     Position: yylex.(*Parser).builder.NewTokensPosition($1, $7),
@@ -941,7 +947,9 @@ statement:
             {
                 $3.(*ast.StmtUnset).UnsetTkn = $1
                 $3.(*ast.StmtUnset).OpenParenthesisTkn = $2
-                $3.(*ast.StmtUnset).SeparatorTkns = append($3.(*ast.StmtUnset).SeparatorTkns, $4)
+                if $4 != nil {
+                    $3.(*ast.StmtUnset).SeparatorTkns = append($3.(*ast.StmtUnset).SeparatorTkns, $4)
+                }
                 $3.(*ast.StmtUnset).CloseParenthesisTkn = $5
                 $3.(*ast.StmtUnset).SemiColonTkn = $6
                 $3.(*ast.StmtUnset).Position = yylex.(*Parser).builder.NewTokensPosition($1, $6)
@@ -1815,7 +1823,9 @@ argument_list:
                 argumentList := $2.(*ast.ArgumentList)
                 argumentList.Position = yylex.(*Parser).builder.NewTokensPosition($1, $4)
                 argumentList.OpenParenthesisTkn = $1
-                argumentList.SeparatorTkns = append(argumentList.SeparatorTkns, $3)
+                if $3 != nil {
+                    argumentList.SeparatorTkns = append(argumentList.SeparatorTkns, $3)
+                }
                 argumentList.CloseParenthesisTkn = $4
 
                 $$ = argumentList
@@ -2029,17 +2039,17 @@ trait_adaptations:
             {
                 $$ = &ast.StmtTraitAdaptationList{
                     Position: yylex.(*Parser).builder.NewTokensPosition($1, $2),
-                    OpenParenthesisTkn:  $1,
-                    CloseParenthesisTkn: $2,
+                    OpenCurlyBracketTkn:  $1,
+                    CloseCurlyBracketTkn: $2,
                 }
             }
     |   '{' trait_adaptation_list '}'
             {
                 $$ = &ast.StmtTraitAdaptationList{
                     Position: yylex.(*Parser).builder.NewTokensPosition($1, $3),
-                    OpenParenthesisTkn:  $1,
-                    Adaptations:         $2,
-                    CloseParenthesisTkn: $3,
+                    OpenCurlyBracketTkn:  $1,
+                    Adaptations:          $2,
+                    CloseCurlyBracketTkn: $3,
                 }
             }
 ;
@@ -2435,7 +2445,7 @@ anonymous_class:
                     OpenParenthesisTkn:  $2.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $2.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $2.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $2.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $2.(*ast.ArgumentList).CloseParenthesisTkn,
                     Extends:             $3,
                     Implements:          $4,
                     OpenCurlyBracket:    $6,
@@ -2456,7 +2466,7 @@ new_expr:
                         OpenParenthesisTkn:  $3.(*ast.ArgumentList).OpenParenthesisTkn,
                         Arguments:           $3.(*ast.ArgumentList).Arguments,
                         SeparatorTkns:       $3.(*ast.ArgumentList).SeparatorTkns,
-                        CloseParenthesisTkn: $3.(*ast.ArgumentList).OpenParenthesisTkn,
+                        CloseParenthesisTkn: $3.(*ast.ArgumentList).CloseParenthesisTkn,
                     }
                 } else {
                     $$ = &ast.ExprNew{
@@ -3284,7 +3294,7 @@ function_call:
                     OpenParenthesisTkn:  $2.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $2.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $2.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $2.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $2.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list
@@ -3297,7 +3307,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   variable_class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list
@@ -3310,7 +3320,7 @@ function_call:
                     OpenParenthesisTkn:  $4.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $4.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $4.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $4.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $4.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
     |   callable_expr argument_list
@@ -3321,7 +3331,7 @@ function_call:
                     OpenParenthesisTkn:  $2.(*ast.ArgumentList).OpenParenthesisTkn,
                     Arguments:           $2.(*ast.ArgumentList).Arguments,
                     SeparatorTkns:       $2.(*ast.ArgumentList).SeparatorTkns,
-                    CloseParenthesisTkn: $2.(*ast.ArgumentList).OpenParenthesisTkn,
+                    CloseParenthesisTkn: $2.(*ast.ArgumentList).CloseParenthesisTkn,
                 }
             }
 ;
@@ -3542,7 +3552,7 @@ scalar:
                     Position: yylex.(*Parser).builder.NewTokensPosition($1, $3),
                     OpenQoteTkn:  $1,
                     Parts:        $2,
-                    CloseQoteTkn: $1,
+                    CloseQoteTkn: $3,
                 }
             }
     |   T_START_HEREDOC encaps_list T_END_HEREDOC
diff --git a/pkg/ast/node.go b/pkg/ast/node.go
index 70655b5..4089027 100644
--- a/pkg/ast/node.go
+++ b/pkg/ast/node.go
@@ -954,10 +954,10 @@ func (n *StmtTrait) GetPosition() *position.Position {
 
 // StmtTraitAdaptationList node
 type StmtTraitAdaptationList struct {
-	Position            *position.Position
-	OpenParenthesisTkn  *token.Token
-	Adaptations         []Vertex
-	CloseParenthesisTkn *token.Token
+	Position             *position.Position
+	OpenCurlyBracketTkn  *token.Token
+	Adaptations          []Vertex
+	CloseCurlyBracketTkn *token.Token
 }
 
 func (n *StmtTraitAdaptationList) Accept(v NodeVisitor) {
diff --git a/pkg/ast/visitor/printer.go b/pkg/ast/visitor/printer.go
new file mode 100644
index 0000000..5d49077
--- /dev/null
+++ b/pkg/ast/visitor/printer.go
@@ -0,0 +1,1239 @@
+package visitor
+
+import (
+	"bytes"
+	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/token"
+	"io"
+)
+
+type printerState int
+
+const (
+	PrinterStateHTML printerState = iota
+	PrinterStatePHP
+)
+
+type printer struct {
+	output io.Writer
+	state  printerState
+	last   []byte
+}
+
+func NewPrinter(output io.Writer) *printer {
+	return &printer{
+		output: output,
+	}
+}
+
+func (p *printer) WithState(state printerState) *printer {
+	p.state = state
+	return p
+}
+
+func isValidVarName(r byte) bool {
+	return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == '_' || r >= 0x80
+}
+
+func (p *printer) write(b []byte) {
+	if len(b) == 0 {
+		return
+	}
+
+	if p.state == PrinterStateHTML {
+		if !bytes.HasPrefix(b, []byte("<?")) {
+			p.output.Write([]byte("<?php "))
+		}
+		p.state = PrinterStatePHP
+	}
+
+	if p.last != nil && isValidVarName(p.last[len(p.last)-1]) && isValidVarName(b[0]) {
+		p.output.Write([]byte(" "))
+	}
+
+	p.last = b
+	p.output.Write(b)
+}
+
+func (p *printer) printNode(n ast.Vertex) {
+	if n != nil {
+		n.Accept(p)
+	}
+}
+
+func (p *printer) printList(list []ast.Vertex) {
+	for _, nn := range list {
+		p.printNode(nn)
+	}
+}
+
+func (p *printer) printSeparatedList(list []ast.Vertex, separators []*token.Token, defaultSeparator []byte) {
+	for k, nn := range list {
+		p.printNode(nn)
+		if k < len(separators) {
+			p.printToken(separators[k], defaultSeparator)
+		} else if k < len(list)-1 {
+			p.write(defaultSeparator)
+		}
+	}
+}
+
+func (p *printer) printToken(t *token.Token, def []byte) {
+	if t == nil && def == nil {
+		return
+	}
+
+	if t == nil {
+		p.write(def)
+		return
+	}
+
+	for _, ff := range t.FreeFloating {
+		p.write(ff.Value)
+	}
+	p.write(t.Value)
+}
+
+func (p *printer) ifNode(n ast.Vertex, val []byte) []byte {
+	if n == nil {
+		return nil
+	}
+
+	return val
+}
+
+func (p *printer) ifNodeList(n []ast.Vertex, val []byte) []byte {
+	if n == nil {
+		return nil
+	}
+
+	return val
+}
+
+func (p *printer) ifNotNodeList(n []ast.Vertex, val []byte) []byte {
+	if n != nil {
+		return nil
+	}
+
+	return val
+}
+
+func (p *printer) ifToken(t *token.Token, true []byte, false []byte) []byte {
+	if t == nil {
+		return false
+	}
+
+	return true
+}
+
+func (p *printer) ifNotToken(t *token.Token, val []byte) []byte {
+	if t != nil {
+		return nil
+	}
+
+	return val
+}
+
+func (p *printer) Root(n *ast.Root) {
+	p.printList(n.Stmts)
+	p.printToken(n.EndTkn, nil)
+}
+
+func (p *printer) Nullable(n *ast.Nullable) {
+	p.printToken(n.QuestionTkn, []byte("?"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) Parameter(n *ast.Parameter) {
+	p.printNode(n.Type)
+	p.printToken(n.AmpersandTkn, nil)
+	p.printToken(n.VariadicTkn, nil)
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, p.ifNode(n.DefaultValue, []byte("=")))
+	p.printNode(n.DefaultValue)
+}
+
+func (p *printer) Identifier(n *ast.Identifier) {
+	p.printToken(n.IdentifierTkn, n.Value)
+}
+
+func (p *printer) Argument(n *ast.Argument) {
+	p.printToken(n.VariadicTkn, nil)
+	p.printToken(n.AmpersandTkn, nil)
+	p.printNode(n.Expr)
+}
+
+func (p *printer) StmtBreak(n *ast.StmtBreak) {
+	p.printToken(n.BreakTkn, []byte("break"))
+	p.printNode(n.Expr)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtCase(n *ast.StmtCase) {
+	p.printToken(n.CaseTkn, []byte("case"))
+	p.printNode(n.Cond)
+	p.printToken(n.CaseSeparatorTkn, []byte(":"))
+	p.printList(n.Stmts)
+}
+
+func (p *printer) StmtCatch(n *ast.StmtCatch) {
+	p.printToken(n.CatchTkn, []byte("catch"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Types, n.SeparatorTkns, []byte("|"))
+	p.printNode(n.Var)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
+func (p *printer) StmtClass(n *ast.StmtClass) {
+	p.printList(n.Modifiers)
+	p.printToken(n.ClassTkn, []byte("class"))
+	p.printNode(n.ClassName)
+	p.printToken(n.OpenParenthesisTkn, p.ifNodeList(n.Arguments, []byte("(")))
+	p.printSeparatedList(n.Arguments, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, p.ifNodeList(n.Arguments, []byte(")")))
+	p.printNode(n.Extends)
+	p.printNode(n.Implements)
+	p.printToken(n.OpenCurlyBracket, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracket, []byte("}"))
+}
+
+func (p *printer) StmtClassConstList(n *ast.StmtClassConstList) {
+	p.printList(n.Modifiers)
+	p.printToken(n.ConstTkn, []byte("const"))
+	p.printSeparatedList(n.Consts, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtClassExtends(n *ast.StmtClassExtends) {
+	p.printToken(n.ExtendTkn, []byte("extends"))
+	p.printNode(n.ClassName)
+}
+
+func (p *printer) StmtClassImplements(n *ast.StmtClassImplements) {
+	p.printToken(n.ImplementsTkn, []byte("implements"))
+	p.printSeparatedList(n.InterfaceNames, n.SeparatorTkns, []byte(","))
+}
+
+func (p *printer) StmtClassMethod(n *ast.StmtClassMethod) {
+	p.printList(n.Modifiers)
+	p.printToken(n.FunctionTkn, []byte("function"))
+	p.printToken(n.AmpersandTkn, nil)
+	p.printNode(n.MethodName)
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Params, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, p.ifNode(n.ReturnType, []byte(":")))
+	p.printNode(n.ReturnType)
+	p.printNode(n.Stmt)
+}
+
+func (p *printer) StmtConstList(n *ast.StmtConstList) {
+	p.printToken(n.ConstTkn, []byte("const"))
+	p.printSeparatedList(n.Consts, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtConstant(n *ast.StmtConstant) {
+	p.printNode(n.Name)
+	p.printToken(n.EqualTkn, []byte("="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) StmtContinue(n *ast.StmtContinue) {
+	p.printToken(n.ContinueTkn, []byte("continue"))
+	p.printNode(n.Expr)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtDeclare(n *ast.StmtDeclare) {
+	p.printToken(n.DeclareTkn, []byte("declare"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Consts, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+	p.printToken(n.EndDeclareTkn, p.ifToken(n.ColonTkn, []byte("enddeclare"), nil))
+	p.printToken(n.SemiColonTkn, p.ifToken(n.ColonTkn, []byte(";"), nil))
+}
+
+func (p *printer) StmtDefault(n *ast.StmtDefault) {
+	p.printToken(n.DefaultTkn, []byte("default"))
+	p.printToken(n.CaseSeparatorTkn, []byte(":"))
+	p.printList(n.Stmts)
+}
+
+func (p *printer) StmtDo(n *ast.StmtDo) {
+	p.printToken(n.DoTkn, []byte("do"))
+	p.printNode(n.Stmt)
+	p.printToken(n.WhileTkn, []byte("while"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Cond)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+
+}
+
+func (p *printer) StmtEcho(n *ast.StmtEcho) {
+	p.printToken(n.EchoTkn, []byte("echo"))
+	p.printSeparatedList(n.Exprs, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtElse(n *ast.StmtElse) {
+	p.printToken(n.ElseTkn, []byte("else"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+}
+
+func (p *printer) StmtElseIf(n *ast.StmtElseIf) {
+	p.printToken(n.ElseIfTkn, []byte("elseif"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Cond)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+}
+
+func (p *printer) StmtExpression(n *ast.StmtExpression) {
+	p.printNode(n.Expr)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtFinally(n *ast.StmtFinally) {
+	p.printToken(n.FinallyTkn, []byte("finally"))
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
+func (p *printer) StmtFor(n *ast.StmtFor) {
+	p.printToken(n.ForTkn, []byte("for"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Init, n.InitSeparatorTkns, []byte(","))
+	p.printToken(n.InitSemiColonTkn, []byte(";"))
+	p.printSeparatedList(n.Cond, n.CondSeparatorTkns, []byte(","))
+	p.printToken(n.CondSemiColonTkn, []byte(";"))
+	p.printSeparatedList(n.Loop, n.LoopSeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+	p.printToken(n.EndForTkn, p.ifToken(n.ColonTkn, []byte("endfor"), nil))
+	p.printToken(n.SemiColonTkn, p.ifToken(n.ColonTkn, []byte(";"), nil))
+}
+
+func (p *printer) StmtForeach(n *ast.StmtForeach) {
+	p.printToken(n.ForeachTkn, []byte("foreach"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Expr)
+	p.printToken(n.AsTkn, []byte("as"))
+	p.printNode(n.Key)
+	p.printToken(n.DoubleArrowTkn, p.ifNode(n.Key, []byte("=>")))
+	p.printNode(n.Var)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+	p.printToken(n.EndForeachTkn, p.ifToken(n.ColonTkn, []byte("endforeach"), nil))
+	p.printToken(n.SemiColonTkn, p.ifToken(n.ColonTkn, []byte(";"), nil))
+}
+
+func (p *printer) StmtFunction(n *ast.StmtFunction) {
+	p.printToken(n.FunctionTkn, []byte("function"))
+	p.printToken(n.AmpersandTkn, nil)
+	p.printNode(n.FunctionName)
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Params, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, p.ifNode(n.ReturnType, []byte(":")))
+	p.printNode(n.ReturnType)
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
+func (p *printer) StmtGlobal(n *ast.StmtGlobal) {
+	p.printToken(n.GlobalTkn, []byte("global"))
+	p.printSeparatedList(n.Vars, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtGoto(n *ast.StmtGoto) {
+	p.printToken(n.GotoTkn, []byte("goto"))
+	p.printNode(n.Label)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtHaltCompiler(n *ast.StmtHaltCompiler) {
+	p.printToken(n.HaltCompilerTkn, []byte("__halt_compiler"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtIf(n *ast.StmtIf) {
+	p.printToken(n.IfTkn, []byte("if"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Cond)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+	p.printList(n.ElseIf)
+	p.printNode(n.Else)
+	p.printToken(n.EndIfTkn, p.ifToken(n.ColonTkn, []byte("endif"), nil))
+	p.printToken(n.SemiColonTkn, p.ifToken(n.ColonTkn, []byte(";"), nil))
+}
+
+func (p *printer) StmtInlineHtml(n *ast.StmtInlineHtml) {
+	p.state = PrinterStatePHP
+	if p.last != nil && !bytes.HasSuffix(p.last, []byte("?>")) && !bytes.HasSuffix(p.last, []byte("?>\n")) {
+		p.write([]byte("?>"))
+	}
+
+	p.printToken(n.InlineHtmlTkn, n.Value)
+	p.state = PrinterStateHTML
+}
+
+func (p *printer) StmtInterface(n *ast.StmtInterface) {
+	p.printToken(n.InterfaceTkn, []byte("interface"))
+	p.printNode(n.InterfaceName)
+	p.printNode(n.Extends)
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
+func (p *printer) StmtInterfaceExtends(n *ast.StmtInterfaceExtends) {
+	p.printToken(n.ExtendsTkn, []byte("extends"))
+	p.printSeparatedList(n.InterfaceNames, n.SeparatorTkns, []byte(","))
+}
+
+func (p *printer) StmtLabel(n *ast.StmtLabel) {
+	p.printNode(n.LabelName)
+	p.printToken(n.ColonTkn, []byte(":"))
+}
+
+func (p *printer) StmtNamespace(n *ast.StmtNamespace) {
+	p.printToken(n.NsTkn, []byte("namespace"))
+	p.printNode(n.Name)
+	p.printToken(n.OpenCurlyBracket, p.ifNodeList(n.Stmts, []byte("{")))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracket, p.ifNodeList(n.Stmts, []byte("}")))
+	p.printToken(n.SemiColonTkn, p.ifNotNodeList(n.Stmts, []byte(";")))
+}
+
+func (p *printer) StmtNop(n *ast.StmtNop) {
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtProperty(n *ast.StmtProperty) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, p.ifNode(n.Expr, []byte("=")))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) StmtPropertyList(n *ast.StmtPropertyList) {
+	p.printList(n.Modifiers)
+	p.printNode(n.Type)
+	p.printSeparatedList(n.Properties, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtReturn(n *ast.StmtReturn) {
+	p.printToken(n.ReturnTkn, []byte("return"))
+	p.printNode(n.Expr)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtStatic(n *ast.StmtStatic) {
+	p.printToken(n.StaticTkn, []byte("static"))
+	p.printSeparatedList(n.Vars, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtStaticVar(n *ast.StmtStaticVar) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, p.ifNode(n.Expr, []byte("=")))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) StmtStmtList(n *ast.StmtStmtList) {
+	p.printToken(n.OpenCurlyBracket, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracket, []byte("}"))
+}
+
+func (p *printer) StmtSwitch(n *ast.StmtSwitch) {
+	p.printToken(n.SwitchTkn, []byte("switch"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Cond)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	p.printToken(n.OpenCurlyBracketTkn, p.ifNotToken(n.ColonTkn, []byte("{")))
+	p.printToken(n.CaseSeparatorTkn, nil)
+	p.printList(n.CaseList)
+	p.printToken(n.CloseCurlyBracketTkn, p.ifNotToken(n.ColonTkn, []byte("}")))
+	p.printToken(n.EndSwitchTkn, p.ifToken(n.ColonTkn, []byte("endswitch"), nil))
+	p.printToken(n.SemiColonTkn, p.ifToken(n.ColonTkn, []byte(";"), nil))
+}
+
+func (p *printer) StmtThrow(n *ast.StmtThrow) {
+	p.printToken(n.ThrowTkn, []byte("throw"))
+	p.printNode(n.Expr)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtTrait(n *ast.StmtTrait) {
+	p.printToken(n.TraitTkn, []byte("trait"))
+	p.printNode(n.TraitName)
+	p.printNode(n.Extends)
+	p.printNode(n.Implements)
+	p.printToken(n.OpenCurlyBracket, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracket, []byte("}"))
+}
+
+func (p *printer) StmtTraitAdaptationList(n *ast.StmtTraitAdaptationList) {
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printList(n.Adaptations)
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
+func (p *printer) StmtTraitMethodRef(n *ast.StmtTraitMethodRef) {
+	p.printNode(n.Trait)
+	p.printToken(n.DoubleColonTkn, p.ifNode(n.Trait, []byte("::")))
+	p.printNode(n.Method)
+}
+
+func (p *printer) StmtTraitUse(n *ast.StmtTraitUse) {
+	p.printToken(n.UseTkn, []byte("use"))
+	p.printSeparatedList(n.Traits, n.SeparatorTkns, []byte(","))
+	p.printNode(n.Adaptations)
+}
+
+func (p *printer) StmtTraitUseAlias(n *ast.StmtTraitUseAlias) {
+	p.printNode(n.Ref)
+	p.printToken(n.AsTkn, []byte("as"))
+	p.printNode(n.Modifier)
+	p.printNode(n.Alias)
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtTraitUsePrecedence(n *ast.StmtTraitUsePrecedence) {
+	p.printNode(n.Ref)
+	p.printToken(n.InsteadofTkn, []byte("insteadof"))
+	p.printSeparatedList(n.Insteadof, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtTry(n *ast.StmtTry) {
+	p.printToken(n.TryTkn, []byte("try"))
+	p.printToken(n.OpenCurlyBracket, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracket, []byte("}"))
+	p.printList(n.Catches)
+	p.printNode(n.Finally)
+}
+
+func (p *printer) StmtUnset(n *ast.StmtUnset) {
+	p.printToken(n.UnsetTkn, []byte("unset"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Vars, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtUse(n *ast.StmtUse) {
+	p.printToken(n.UseTkn, []byte("use"))
+	p.printNode(n.Type)
+	p.printSeparatedList(n.UseDeclarations, n.SeparatorTkns, []byte(","))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtGroupUse(n *ast.StmtGroupUse) {
+	p.printToken(n.UseTkn, []byte("use"))
+	p.printNode(n.Type)
+	p.printToken(n.LeadingNsSeparatorTkn, nil)
+	p.printNode(n.Prefix)
+	p.printToken(n.NsSeparatorTkn, []byte("\\"))
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printSeparatedList(n.UseDeclarations, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+	p.printToken(n.SemiColonTkn, []byte(";"))
+}
+
+func (p *printer) StmtUseDeclaration(n *ast.StmtUseDeclaration) {
+	p.printNode(n.Type)
+	p.printToken(n.NsSeparatorTkn, nil)
+	p.printNode(n.Use)
+	p.printToken(n.AsTkn, p.ifNode(n.Alias, []byte("as")))
+	p.printNode(n.Alias)
+}
+
+func (p *printer) StmtWhile(n *ast.StmtWhile) {
+	p.printToken(n.WhileTkn, []byte("while"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Cond)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, nil)
+	if stmt, ok := n.Stmt.(*ast.StmtStmtList); ok && n.ColonTkn != nil {
+		p.printToken(stmt.OpenCurlyBracket, nil)
+		p.printList(stmt.Stmts)
+		p.printToken(stmt.CloseCurlyBracket, nil)
+	} else {
+		p.printNode(n.Stmt)
+	}
+	p.printToken(n.EndWhileTkn, p.ifToken(n.ColonTkn, []byte("endwhile"), nil))
+	p.printToken(n.SemiColonTkn, p.ifToken(n.ColonTkn, []byte(";"), nil))
+}
+
+func (p *printer) ExprArray(n *ast.ExprArray) {
+	p.printToken(n.ArrayTkn, nil)
+	p.printToken(n.OpenBracketTkn, p.ifToken(n.ArrayTkn, []byte("("), []byte("[")))
+	p.printSeparatedList(n.Items, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseBracketTkn, p.ifToken(n.ArrayTkn, []byte(")"), []byte("]")))
+}
+
+func (p *printer) ExprArrayDimFetch(n *ast.ExprArrayDimFetch) {
+	p.printNode(n.Var)
+	p.printToken(n.OpenBracketTkn, []byte("["))
+	p.printNode(n.Dim)
+	p.printToken(n.CloseBracketTkn, []byte("]"))
+}
+
+func (p *printer) ExprArrayItem(n *ast.ExprArrayItem) {
+	p.printToken(n.EllipsisTkn, nil)
+	p.printNode(n.Key)
+	p.printToken(n.DoubleArrowTkn, p.ifNode(n.Key, []byte("=>")))
+	p.printNode(n.Val)
+}
+
+func (p *printer) ExprArrowFunction(n *ast.ExprArrowFunction) {
+	p.printToken(n.StaticTkn, nil)
+	p.printToken(n.FnTkn, []byte("fn"))
+	p.printToken(n.AmpersandTkn, nil)
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Params, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printToken(n.ColonTkn, p.ifNode(n.ReturnType, []byte(":")))
+	p.printNode(n.ReturnType)
+	p.printToken(n.DoubleArrowTkn, []byte("=>"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprBitwiseNot(n *ast.ExprBitwiseNot) {
+	p.printToken(n.TildaTkn, []byte("~"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprBooleanNot(n *ast.ExprBooleanNot) {
+	p.printToken(n.ExclamationTkn, []byte("!"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprClassConstFetch(n *ast.ExprClassConstFetch) {
+	p.printNode(n.Class)
+	p.printToken(n.DoubleColonTkn, []byte("::"))
+	p.printNode(n.ConstantName)
+}
+
+func (p *printer) ExprClone(n *ast.ExprClone) {
+	p.printToken(n.CloneTkn, []byte("clone"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprClosure(n *ast.ExprClosure) {
+	p.printToken(n.StaticTkn, nil)
+	p.printToken(n.FunctionTkn, []byte("function"))
+	p.printToken(n.AmpersandTkn, nil)
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Params, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+	p.printNode(n.ClosureUse)
+	p.printToken(n.ColonTkn, p.ifNode(n.ReturnType, []byte(":")))
+	p.printNode(n.ReturnType)
+	p.printToken(n.OpenCurlyBracketTkn, []byte("{"))
+	p.printList(n.Stmts)
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
+func (p *printer) ExprClosureUse(n *ast.ExprClosureUse) {
+	p.printToken(n.UseTkn, []byte("use"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Uses, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+}
+
+func (p *printer) ExprConstFetch(n *ast.ExprConstFetch) {
+	p.printNode(n.Const)
+}
+
+func (p *printer) ExprEmpty(n *ast.ExprEmpty) {
+	p.printToken(n.EmptyTkn, []byte("empty"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Expr)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+}
+
+func (p *printer) ExprErrorSuppress(n *ast.ExprErrorSuppress) {
+	p.printToken(n.AtTkn, []byte("@"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprEval(n *ast.ExprEval) {
+	p.printToken(n.EvalTkn, []byte("eval"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printNode(n.Expr)
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+}
+
+func (p *printer) ExprExit(n *ast.ExprExit) {
+	p.printToken(n.DieTkn, []byte("exit"))
+	p.printToken(n.OpenParenthesisTkn, nil)
+	p.printNode(n.Expr)
+	p.printToken(n.CloseParenthesisTkn, p.ifToken(n.OpenParenthesisTkn, []byte(")"), nil))
+}
+
+func (p *printer) ExprFunctionCall(n *ast.ExprFunctionCall) {
+	p.printNode(n.Function)
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Arguments, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+}
+
+func (p *printer) ExprInclude(n *ast.ExprInclude) {
+	p.printToken(n.IncludeTkn, []byte("include"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprIncludeOnce(n *ast.ExprIncludeOnce) {
+	p.printToken(n.IncludeTkn, []byte("include_once"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprInstanceOf(n *ast.ExprInstanceOf) {
+	p.printNode(n.Expr)
+	p.printToken(n.InstanceOfTkn, []byte("instanceof"))
+	p.printNode(n.Class)
+}
+
+func (p *printer) ExprIsset(n *ast.ExprIsset) {
+	p.printToken(n.IssetTkn, []byte("isset"))
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Vars, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+}
+
+func (p *printer) ExprList(n *ast.ExprList) {
+	p.printToken(n.ListTkn, p.ifToken(n.OpenBracketTkn, nil, []byte("list")))
+	p.printToken(n.OpenBracketTkn, []byte("("))
+	p.printSeparatedList(n.Items, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseBracketTkn, []byte(")"))
+}
+
+func (p *printer) ExprMethodCall(n *ast.ExprMethodCall) {
+	p.printNode(n.Var)
+	p.printToken(n.ObjectOperatorTkn, []byte("->"))
+	p.printNode(n.Method)
+	p.printToken(n.OpenParenthesisTkn, []byte("("))
+	p.printSeparatedList(n.Arguments, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, []byte(")"))
+}
+
+func (p *printer) ExprNew(n *ast.ExprNew) {
+	p.printToken(n.NewTkn, []byte("new"))
+	p.printNode(n.Class)
+	p.printToken(n.OpenParenthesisTkn, p.ifNodeList(n.Arguments, []byte("(")))
+	p.printSeparatedList(n.Arguments, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, p.ifNodeList(n.Arguments, []byte(")")))
+}
+
+func (p *printer) ExprPostDec(n *ast.ExprPostDec) {
+	p.printNode(n.Var)
+	p.printToken(n.DecTkn, []byte("--"))
+}
+
+func (p *printer) ExprPostInc(n *ast.ExprPostInc) {
+	p.printNode(n.Var)
+	p.printToken(n.IncTkn, []byte("++"))
+}
+
+func (p *printer) ExprPreDec(n *ast.ExprPreDec) {
+	p.printToken(n.DecTkn, []byte("--"))
+	p.printNode(n.Var)
+}
+
+func (p *printer) ExprPreInc(n *ast.ExprPreInc) {
+	p.printToken(n.IncTkn, []byte("++"))
+	p.printNode(n.Var)
+}
+
+func (p *printer) ExprPrint(n *ast.ExprPrint) {
+	p.printToken(n.PrintTkn, []byte("print"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprPropertyFetch(n *ast.ExprPropertyFetch) {
+	p.printNode(n.Var)
+	p.printToken(n.ObjectOperatorTkn, []byte("->"))
+	p.printNode(n.Property)
+}
+
+func (p *printer) ExprReference(n *ast.ExprReference) {
+	p.printToken(n.AmpersandTkn, []byte("&"))
+	p.printNode(n.Var)
+}
+
+func (p *printer) ExprRequire(n *ast.ExprRequire) {
+	p.printToken(n.RequireTkn, []byte("require"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprRequireOnce(n *ast.ExprRequireOnce) {
+	p.printToken(n.RequireOnceTkn, []byte("require_once"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprShellExec(n *ast.ExprShellExec) {
+	p.printToken(n.OpenBacktickTkn, []byte("`"))
+	p.printList(n.Parts)
+	p.printToken(n.CloseBacktickTkn, []byte("`"))
+}
+
+func (p *printer) ExprStaticCall(n *ast.ExprStaticCall) {
+	p.printNode(n.Class)
+	p.printToken(n.DoubleColonTkn, []byte("::"))
+	p.printNode(n.Call)
+	p.printToken(n.OpenParenthesisTkn, p.ifNodeList(n.Arguments, []byte("(")))
+	p.printSeparatedList(n.Arguments, n.SeparatorTkns, []byte(","))
+	p.printToken(n.CloseParenthesisTkn, p.ifNodeList(n.Arguments, []byte(")")))
+}
+
+func (p *printer) ExprStaticPropertyFetch(n *ast.ExprStaticPropertyFetch) {
+	p.printNode(n.Class)
+	p.printToken(n.DoubleColonTkn, []byte("::"))
+	p.printNode(n.Property)
+}
+
+func (p *printer) ExprTernary(n *ast.ExprTernary) {
+	p.printNode(n.Condition)
+	p.printToken(n.QuestionTkn, []byte("?"))
+	p.printNode(n.IfTrue)
+	p.printToken(n.ColonTkn, []byte(":"))
+	p.printNode(n.IfFalse)
+}
+
+func (p *printer) ExprUnaryMinus(n *ast.ExprUnaryMinus) {
+	p.printToken(n.MinusTkn, []byte("-"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprUnaryPlus(n *ast.ExprUnaryPlus) {
+	p.printToken(n.PlusTkn, []byte("+"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprVariable(n *ast.ExprVariable) {
+	p.printToken(n.DollarTkn, nil)
+	p.printNode(n.VarName)
+}
+
+func (p *printer) ExprYield(n *ast.ExprYield) {
+	p.printToken(n.YieldTkn, []byte("yield"))
+	p.printNode(n.Key)
+	p.printToken(n.DoubleArrowTkn, p.ifNode(n.Key, []byte("=>")))
+	p.printNode(n.Value)
+}
+
+func (p *printer) ExprYieldFrom(n *ast.ExprYieldFrom) {
+	p.printToken(n.YieldFromTkn, []byte("yield from"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssign(n *ast.ExprAssign) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignReference(n *ast.ExprAssignReference) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("="))
+	p.printToken(n.AmpersandTkn, []byte("&"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignBitwiseAnd(n *ast.ExprAssignBitwiseAnd) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("&="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignBitwiseOr(n *ast.ExprAssignBitwiseOr) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("|="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignBitwiseXor(n *ast.ExprAssignBitwiseXor) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("^="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignCoalesce(n *ast.ExprAssignCoalesce) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("??="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignConcat(n *ast.ExprAssignConcat) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte(".="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignDiv(n *ast.ExprAssignDiv) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("/="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignMinus(n *ast.ExprAssignMinus) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("-="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignMod(n *ast.ExprAssignMod) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("%="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignMul(n *ast.ExprAssignMul) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("*="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignPlus(n *ast.ExprAssignPlus) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("+="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignPow(n *ast.ExprAssignPow) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("**="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignShiftLeft(n *ast.ExprAssignShiftLeft) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte("<<="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprAssignShiftRight(n *ast.ExprAssignShiftRight) {
+	p.printNode(n.Var)
+	p.printToken(n.EqualTkn, []byte(">>="))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprBinaryBitwiseAnd(n *ast.ExprBinaryBitwiseAnd) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("&"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryBitwiseOr(n *ast.ExprBinaryBitwiseOr) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("|"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryBitwiseXor(n *ast.ExprBinaryBitwiseXor) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("^"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryBooleanAnd(n *ast.ExprBinaryBooleanAnd) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("&&"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryBooleanOr(n *ast.ExprBinaryBooleanOr) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("||"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryCoalesce(n *ast.ExprBinaryCoalesce) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("??"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryConcat(n *ast.ExprBinaryConcat) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("."))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryDiv(n *ast.ExprBinaryDiv) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("/"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryEqual(n *ast.ExprBinaryEqual) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("=="))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryGreater(n *ast.ExprBinaryGreater) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte(">"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryGreaterOrEqual(n *ast.ExprBinaryGreaterOrEqual) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte(">="))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryIdentical(n *ast.ExprBinaryIdentical) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("==="))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryLogicalAnd(n *ast.ExprBinaryLogicalAnd) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("and"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryLogicalOr(n *ast.ExprBinaryLogicalOr) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("or"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryLogicalXor(n *ast.ExprBinaryLogicalXor) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("xor"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryMinus(n *ast.ExprBinaryMinus) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("-"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryMod(n *ast.ExprBinaryMod) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("%"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryMul(n *ast.ExprBinaryMul) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("*"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryNotEqual(n *ast.ExprBinaryNotEqual) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("!="))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryNotIdentical(n *ast.ExprBinaryNotIdentical) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("!=="))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryPlus(n *ast.ExprBinaryPlus) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("+"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryPow(n *ast.ExprBinaryPow) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("**"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryShiftLeft(n *ast.ExprBinaryShiftLeft) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("<<"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinaryShiftRight(n *ast.ExprBinaryShiftRight) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte(">>"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinarySmaller(n *ast.ExprBinarySmaller) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("<"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinarySmallerOrEqual(n *ast.ExprBinarySmallerOrEqual) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("<="))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprBinarySpaceship(n *ast.ExprBinarySpaceship) {
+	p.printNode(n.Left)
+	p.printToken(n.OpTkn, []byte("<=>"))
+	p.printNode(n.Right)
+}
+
+func (p *printer) ExprCastArray(n *ast.ExprCastArray) {
+	p.printToken(n.CastTkn, []byte("(array)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprCastBool(n *ast.ExprCastBool) {
+	p.printToken(n.CastTkn, []byte("(bool)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprCastDouble(n *ast.ExprCastDouble) {
+	p.printToken(n.CastTkn, []byte("(float)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprCastInt(n *ast.ExprCastInt) {
+	p.printToken(n.CastTkn, []byte("(integer)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprCastObject(n *ast.ExprCastObject) {
+	p.printToken(n.CastTkn, []byte("(object)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprCastString(n *ast.ExprCastString) {
+	p.printToken(n.CastTkn, []byte("(string)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ExprCastUnset(n *ast.ExprCastUnset) {
+	p.printToken(n.CastTkn, []byte("(unset)"))
+	p.printNode(n.Expr)
+}
+
+func (p *printer) ScalarDnumber(n *ast.ScalarDnumber) {
+	p.printToken(n.NumberTkn, n.Value)
+}
+
+func (p *printer) ScalarEncapsed(n *ast.ScalarEncapsed) {
+	p.printToken(n.OpenQoteTkn, []byte("\""))
+	p.printList(n.Parts)
+	p.printToken(n.CloseQoteTkn, []byte("\""))
+}
+
+func (p *printer) ScalarEncapsedStringPart(n *ast.ScalarEncapsedStringPart) {
+	p.printToken(n.EncapsedStrTkn, n.Value)
+}
+
+func (p *printer) ScalarHeredoc(n *ast.ScalarHeredoc) {
+	p.printToken(n.OpenHeredocTkn, []byte("<<<EOT\n"))
+	p.printList(n.Parts)
+	p.printToken(n.CloseHeredocTkn, []byte("EOT"))
+}
+
+func (p *printer) ScalarLnumber(n *ast.ScalarLnumber) {
+	p.printToken(n.NumberTkn, n.Value)
+}
+
+func (p *printer) ScalarMagicConstant(n *ast.ScalarMagicConstant) {
+	p.printToken(n.MagicConstTkn, n.Value)
+}
+
+func (p *printer) ScalarString(n *ast.ScalarString) {
+	p.printToken(n.MinusTkn, nil)
+	p.printToken(n.StringTkn, n.Value)
+}
+
+func (p *printer) NameName(n *ast.NameName) {
+	p.printSeparatedList(n.Parts, n.SeparatorTkns, []byte("\\"))
+}
+
+func (p *printer) NameFullyQualified(n *ast.NameFullyQualified) {
+	p.printToken(n.NsSeparatorTkn, []byte("\\"))
+	p.printSeparatedList(n.Parts, n.SeparatorTkns, []byte("\\"))
+}
+
+func (p *printer) NameRelative(n *ast.NameRelative) {
+	p.printToken(n.NsTkn, []byte("namespace"))
+	p.printToken(n.NsSeparatorTkn, []byte("\\"))
+	p.printSeparatedList(n.Parts, n.SeparatorTkns, []byte("\\"))
+}
+
+func (p *printer) NameNamePart(n *ast.NameNamePart) {
+	p.printToken(n.StringTkn, n.Value)
+}
+
+func (p *printer) ParserBrackets(n *ast.ParserBrackets) {
+	p.printToken(n.OpenBracketTkn, nil)
+	p.printNode(n.Child)
+	p.printToken(n.CloseBracketTkn, nil)
+}
+
+func (p *printer) ParserSeparatedList(n *ast.ParserSeparatedList) {
+	// do nothing
+}
diff --git a/pkg/printer/printer_parsed_php5_test.go b/pkg/ast/visitor/printer_php5_test.go
similarity index 99%
rename from pkg/printer/printer_parsed_php5_test.go
rename to pkg/ast/visitor/printer_php5_test.go
index 75dfafa..c3b0625 100644
--- a/pkg/printer/printer_parsed_php5_test.go
+++ b/pkg/ast/visitor/printer_php5_test.go
@@ -1,14 +1,14 @@
-package printer_test
+package visitor_test
 
 import (
 	"bytes"
+	"github.com/z7zmey/php-parser/pkg/ast/visitor"
 	"testing"
 
 	"github.com/z7zmey/php-parser/pkg/ast"
 
 	"github.com/z7zmey/php-parser/internal/php5"
 	"github.com/z7zmey/php-parser/internal/scanner"
-	"github.com/z7zmey/php-parser/pkg/printer"
 )
 
 func parsePhp5(src string) ast.Vertex {
@@ -22,8 +22,8 @@ func parsePhp5(src string) ast.Vertex {
 func printPhp5(n ast.Vertex) string {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(n)
+	printer := visitor.NewPrinter(o)
+	n.Accept(printer)
 
 	return o.String()
 }
diff --git a/pkg/printer/printer_parsed_php7_test.go b/pkg/ast/visitor/printer_php7_test.go
similarity index 99%
rename from pkg/printer/printer_parsed_php7_test.go
rename to pkg/ast/visitor/printer_php7_test.go
index 7d7f5b9..c75e6ba 100644
--- a/pkg/printer/printer_parsed_php7_test.go
+++ b/pkg/ast/visitor/printer_php7_test.go
@@ -1,15 +1,14 @@
-package printer_test
+package visitor_test
 
 import (
 	"bytes"
 	"os"
 	"testing"
 
-	"github.com/z7zmey/php-parser/pkg/ast"
-
 	"github.com/z7zmey/php-parser/internal/php7"
 	"github.com/z7zmey/php-parser/internal/scanner"
-	"github.com/z7zmey/php-parser/pkg/printer"
+	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/ast/visitor"
 )
 
 func ExamplePrinter() {
@@ -42,8 +41,8 @@ abstract class Bar extends Baz
 
 	// print
 
-	p := printer.NewPrinter(os.Stdout)
-	p.Print(rootNode)
+	printer := visitor.NewPrinter(os.Stdout)
+	rootNode.Accept(printer)
 
 	// Output:
 	//<?php
@@ -71,8 +70,8 @@ func parse(src string) ast.Vertex {
 func print(n ast.Vertex) string {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(n)
+	printer := visitor.NewPrinter(o)
+	n.Accept(printer)
 
 	return o.String()
 }
diff --git a/pkg/printer/printer_test.go b/pkg/ast/visitor/printer_test.go
similarity index 75%
rename from pkg/printer/printer_test.go
rename to pkg/ast/visitor/printer_test.go
index 8956574..7920cb2 100644
--- a/pkg/printer/printer_test.go
+++ b/pkg/ast/visitor/printer_test.go
@@ -1,18 +1,19 @@
-package printer_test
+package visitor_test
 
 import (
 	"bytes"
+	"github.com/z7zmey/php-parser/pkg/token"
 	"testing"
 
 	"github.com/z7zmey/php-parser/pkg/ast"
-	"github.com/z7zmey/php-parser/pkg/printer"
+	"github.com/z7zmey/php-parser/pkg/ast/visitor"
 )
 
 func TestPrinterPrintFile(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Root{
+	p := visitor.NewPrinter(o)
+	n := &ast.Root{
 		Stmts: []ast.Vertex{
 			&ast.StmtNamespace{
 				Name: &ast.NameName{
@@ -52,9 +53,10 @@ func TestPrinterPrintFile(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `<?php namespace Foo;abstract class Bar extends Baz{public function greet(){echo 'Hello world';}}`
+	expected := `<?php namespace Foo;abstract class Bar extends Baz{public function greet(){echo'Hello world';}}`
 	actual := o.String()
 
 	if expected != actual {
@@ -65,8 +67,8 @@ func TestPrinterPrintFile(t *testing.T) {
 func TestPrinterPrintFileInlineHtml(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Root{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.Root{
 		Stmts: []ast.Vertex{
 			&ast.StmtInlineHtml{Value: []byte("<div>HTML</div>")},
 			&ast.StmtEcho{
@@ -85,9 +87,10 @@ func TestPrinterPrintFileInlineHtml(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `<div>HTML</div><?php echo "a";?><div>HTML</div><?php echo "b";`
+	expected := `<div>HTML</div><?php echo"a";?><div>HTML</div><?php echo"b";`
 	actual := o.String()
 
 	if expected != actual {
@@ -100,11 +103,11 @@ func TestPrinterPrintFileInlineHtml(t *testing.T) {
 func TestPrinterPrintIdentifier(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
 	n := &ast.Identifier{
 		Value: []byte("test"),
 	}
-	p.Print(n)
+	n.Accept(p)
 
 	expected := `test`
 	actual := o.String()
@@ -117,8 +120,8 @@ func TestPrinterPrintIdentifier(t *testing.T) {
 func TestPrinterPrintParameter(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Parameter{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.Parameter{
 		Type: &ast.NameFullyQualified{
 			Parts: []ast.Vertex{
 				&ast.NameNamePart{
@@ -126,15 +129,17 @@ func TestPrinterPrintParameter(t *testing.T) {
 				},
 			},
 		},
-		Var: &ast.Variadic{
-			Var: &ast.ExprVariable{
-				VarName: &ast.Identifier{Value: []byte("$var")},
-			},
+		VariadicTkn: &token.Token{
+			Value: []byte("..."),
+		},
+		Var: &ast.ExprVariable{
+			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
 		DefaultValue: &ast.ScalarString{
 			Value: []byte("'default'"),
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "\\Foo...$var='default'"
 	actual := o.String()
@@ -147,8 +152,8 @@ func TestPrinterPrintParameter(t *testing.T) {
 func TestPrinterPrintNullable(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Nullable{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.Nullable{
 		Expr: &ast.Parameter{
 			Type: &ast.NameFullyQualified{
 				Parts: []ast.Vertex{
@@ -157,16 +162,18 @@ func TestPrinterPrintNullable(t *testing.T) {
 					},
 				},
 			},
-			Var: &ast.Reference{
-				Var: &ast.ExprVariable{
-					VarName: &ast.Identifier{Value: []byte("$var")},
-				},
+			AmpersandTkn: &token.Token{
+				Value: []byte("&"),
+			},
+			Var: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("$var")},
 			},
 			DefaultValue: &ast.ScalarString{
 				Value: []byte("'default'"),
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "?\\Foo&$var='default'"
 	actual := o.String()
@@ -179,14 +186,16 @@ func TestPrinterPrintNullable(t *testing.T) {
 func TestPrinterPrintArgument(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Argument{
-		IsReference: false,
-		Variadic:    true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.Argument{
+		VariadicTkn: &token.Token{
+			Value: []byte("..."),
+		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "...$var"
 	actual := o.String()
@@ -198,14 +207,16 @@ func TestPrinterPrintArgument(t *testing.T) {
 func TestPrinterPrintArgumentByRef(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Argument{
-		IsReference: true,
-		Variadic:    false,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.Argument{
+		AmpersandTkn: &token.Token{
+			Value: []byte("&"),
+		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "&$var"
 	actual := o.String()
@@ -220,10 +231,11 @@ func TestPrinterPrintArgumentByRef(t *testing.T) {
 func TestPrinterPrintNameNamePart(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.NameNamePart{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.NameNamePart{
 		Value: []byte("foo"),
-	})
+	}
+	n.Accept(p)
 
 	expected := "foo"
 	actual := o.String()
@@ -236,8 +248,8 @@ func TestPrinterPrintNameNamePart(t *testing.T) {
 func TestPrinterPrintNameName(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.NameName{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.NameName{
 		Parts: []ast.Vertex{
 			&ast.NameNamePart{
 				Value: []byte("Foo"),
@@ -246,7 +258,8 @@ func TestPrinterPrintNameName(t *testing.T) {
 				Value: []byte("Bar"),
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "Foo\\Bar"
 	actual := o.String()
@@ -259,8 +272,8 @@ func TestPrinterPrintNameName(t *testing.T) {
 func TestPrinterPrintNameFullyQualified(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.NameFullyQualified{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.NameFullyQualified{
 		Parts: []ast.Vertex{
 			&ast.NameNamePart{
 				Value: []byte("Foo"),
@@ -269,7 +282,8 @@ func TestPrinterPrintNameFullyQualified(t *testing.T) {
 				Value: []byte("Bar"),
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "\\Foo\\Bar"
 	actual := o.String()
@@ -282,8 +296,8 @@ func TestPrinterPrintNameFullyQualified(t *testing.T) {
 func TestPrinterPrintNameRelative(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.NameRelative{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.NameRelative{
 		Parts: []ast.Vertex{
 			&ast.NameNamePart{
 				Value: []byte("Foo"),
@@ -292,7 +306,8 @@ func TestPrinterPrintNameRelative(t *testing.T) {
 				Value: []byte("Bar"),
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "namespace\\Foo\\Bar"
 	actual := o.String()
@@ -307,10 +322,11 @@ func TestPrinterPrintNameRelative(t *testing.T) {
 func TestPrinterPrintScalarLNumber(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarLnumber{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarLnumber{
 		Value: []byte("1"),
-	})
+	}
+	n.Accept(p)
 
 	expected := "1"
 	actual := o.String()
@@ -323,10 +339,11 @@ func TestPrinterPrintScalarLNumber(t *testing.T) {
 func TestPrinterPrintScalarDNumber(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarDnumber{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarDnumber{
 		Value: []byte(".1"),
-	})
+	}
+	n.Accept(p)
 
 	expected := ".1"
 	actual := o.String()
@@ -339,10 +356,11 @@ func TestPrinterPrintScalarDNumber(t *testing.T) {
 func TestPrinterPrintScalarString(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarString{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarString{
 		Value: []byte("'hello world'"),
-	})
+	}
+	n.Accept(p)
 
 	expected := `'hello world'`
 	actual := o.String()
@@ -355,10 +373,11 @@ func TestPrinterPrintScalarString(t *testing.T) {
 func TestPrinterPrintScalarEncapsedStringPart(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarEncapsedStringPart{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarEncapsedStringPart{
 		Value: []byte("hello world"),
-	})
+	}
+	n.Accept(p)
 
 	expected := `hello world`
 	actual := o.String()
@@ -371,8 +390,8 @@ func TestPrinterPrintScalarEncapsedStringPart(t *testing.T) {
 func TestPrinterPrintScalarEncapsed(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarEncapsed{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarEncapsed{
 		Parts: []ast.Vertex{
 			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
 			&ast.ExprVariable{
@@ -380,7 +399,8 @@ func TestPrinterPrintScalarEncapsed(t *testing.T) {
 			},
 			&ast.ScalarEncapsedStringPart{Value: []byte(" world")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `"hello $var world"`
 	actual := o.String()
@@ -393,9 +413,8 @@ func TestPrinterPrintScalarEncapsed(t *testing.T) {
 func TestPrinterPrintScalarHeredoc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarHeredoc{
-		Label: []byte("<<<LBL\n"),
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarHeredoc{
 		Parts: []ast.Vertex{
 			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
 			&ast.ExprVariable{
@@ -403,32 +422,12 @@ func TestPrinterPrintScalarHeredoc(t *testing.T) {
 			},
 			&ast.ScalarEncapsedStringPart{Value: []byte(" world\n")},
 		},
-	})
-
-	expected := `<<<LBL
-hello $var world
-LBL`
-	actual := o.String()
-
-	if expected != actual {
-		t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
 	}
-}
+	n.Accept(p)
 
-func TestPrinterPrintScalarNowdoc(t *testing.T) {
-	o := bytes.NewBufferString("")
-
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarHeredoc{
-		Label: []byte("<<<'LBL'\n"),
-		Parts: []ast.Vertex{
-			&ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
-		},
-	})
-
-	expected := `<<<'LBL'
-hello world
-LBL`
+	expected := `<<<EOT
+hello $var world
+EOT`
 	actual := o.String()
 
 	if expected != actual {
@@ -439,10 +438,11 @@ LBL`
 func TestPrinterPrintScalarMagicConstant(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ScalarMagicConstant{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ScalarMagicConstant{
 		Value: []byte("__DIR__"),
-	})
+	}
+	n.Accept(p)
 
 	if o.String() != `__DIR__` {
 		t.Errorf("TestPrintScalarMagicConstant is failed\n")
@@ -454,15 +454,16 @@ func TestPrinterPrintScalarMagicConstant(t *testing.T) {
 func TestPrinterPrintAssign(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssign{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssign{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a=$b`
 	actual := o.String()
@@ -475,15 +476,16 @@ func TestPrinterPrintAssign(t *testing.T) {
 func TestPrinterPrintReference(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignReference{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignReference{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a=&$b`
 	actual := o.String()
@@ -496,15 +498,16 @@ func TestPrinterPrintReference(t *testing.T) {
 func TestPrinterPrintAssignBitwiseAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignBitwiseAnd{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignBitwiseAnd{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a&=$b`
 	actual := o.String()
@@ -517,15 +520,16 @@ func TestPrinterPrintAssignBitwiseAnd(t *testing.T) {
 func TestPrinterPrintAssignBitwiseOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignBitwiseOr{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignBitwiseOr{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a|=$b`
 	actual := o.String()
@@ -538,15 +542,16 @@ func TestPrinterPrintAssignBitwiseOr(t *testing.T) {
 func TestPrinterPrintAssignBitwiseXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignBitwiseXor{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignBitwiseXor{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a^=$b`
 	actual := o.String()
@@ -559,15 +564,16 @@ func TestPrinterPrintAssignBitwiseXor(t *testing.T) {
 func TestPrinterPrintAssignCoalesce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignCoalesce{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignCoalesce{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a??=$b`
 	actual := o.String()
@@ -580,15 +586,16 @@ func TestPrinterPrintAssignCoalesce(t *testing.T) {
 func TestPrinterPrintAssignConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignConcat{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignConcat{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a.=$b`
 	actual := o.String()
@@ -601,15 +608,16 @@ func TestPrinterPrintAssignConcat(t *testing.T) {
 func TestPrinterPrintAssignDiv(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignDiv{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignDiv{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a/=$b`
 	actual := o.String()
@@ -622,15 +630,16 @@ func TestPrinterPrintAssignDiv(t *testing.T) {
 func TestPrinterPrintAssignMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignMinus{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignMinus{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a-=$b`
 	actual := o.String()
@@ -643,15 +652,16 @@ func TestPrinterPrintAssignMinus(t *testing.T) {
 func TestPrinterPrintAssignMod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignMod{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignMod{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a%=$b`
 	actual := o.String()
@@ -664,15 +674,16 @@ func TestPrinterPrintAssignMod(t *testing.T) {
 func TestPrinterPrintAssignMul(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignMul{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignMul{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a*=$b`
 	actual := o.String()
@@ -685,15 +696,16 @@ func TestPrinterPrintAssignMul(t *testing.T) {
 func TestPrinterPrintAssignPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignPlus{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignPlus{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a+=$b`
 	actual := o.String()
@@ -706,15 +718,16 @@ func TestPrinterPrintAssignPlus(t *testing.T) {
 func TestPrinterPrintAssignPow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignPow{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignPow{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a**=$b`
 	actual := o.String()
@@ -727,15 +740,16 @@ func TestPrinterPrintAssignPow(t *testing.T) {
 func TestPrinterPrintAssignShiftLeft(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignShiftLeft{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignShiftLeft{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a<<=$b`
 	actual := o.String()
@@ -748,15 +762,16 @@ func TestPrinterPrintAssignShiftLeft(t *testing.T) {
 func TestPrinterPrintAssignShiftRight(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprAssignShiftRight{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprAssignShiftRight{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a>>=$b`
 	actual := o.String()
@@ -771,15 +786,16 @@ func TestPrinterPrintAssignShiftRight(t *testing.T) {
 func TestPrinterPrintBinaryBitwiseAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryBitwiseAnd{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryBitwiseAnd{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a&$b`
 	actual := o.String()
@@ -792,15 +808,16 @@ func TestPrinterPrintBinaryBitwiseAnd(t *testing.T) {
 func TestPrinterPrintBinaryBitwiseOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryBitwiseOr{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryBitwiseOr{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a|$b`
 	actual := o.String()
@@ -813,15 +830,16 @@ func TestPrinterPrintBinaryBitwiseOr(t *testing.T) {
 func TestPrinterPrintBinaryBitwiseXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryBitwiseXor{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryBitwiseXor{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a^$b`
 	actual := o.String()
@@ -834,15 +852,16 @@ func TestPrinterPrintBinaryBitwiseXor(t *testing.T) {
 func TestPrinterPrintBinaryBooleanAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryBooleanAnd{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryBooleanAnd{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a&&$b`
 	actual := o.String()
@@ -855,15 +874,16 @@ func TestPrinterPrintBinaryBooleanAnd(t *testing.T) {
 func TestPrinterPrintBinaryBooleanOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryBooleanOr{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryBooleanOr{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a||$b`
 	actual := o.String()
@@ -876,15 +896,16 @@ func TestPrinterPrintBinaryBooleanOr(t *testing.T) {
 func TestPrinterPrintBinaryCoalesce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryCoalesce{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryCoalesce{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a??$b`
 	actual := o.String()
@@ -897,15 +918,16 @@ func TestPrinterPrintBinaryCoalesce(t *testing.T) {
 func TestPrinterPrintBinaryConcat(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryConcat{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryConcat{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a.$b`
 	actual := o.String()
@@ -918,15 +940,16 @@ func TestPrinterPrintBinaryConcat(t *testing.T) {
 func TestPrinterPrintBinaryDiv(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryDiv{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryDiv{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a/$b`
 	actual := o.String()
@@ -939,15 +962,16 @@ func TestPrinterPrintBinaryDiv(t *testing.T) {
 func TestPrinterPrintBinaryEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryEqual{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryEqual{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a==$b`
 	actual := o.String()
@@ -960,15 +984,16 @@ func TestPrinterPrintBinaryEqual(t *testing.T) {
 func TestPrinterPrintBinaryGreaterOrEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryGreaterOrEqual{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryGreaterOrEqual{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a>=$b`
 	actual := o.String()
@@ -981,15 +1006,16 @@ func TestPrinterPrintBinaryGreaterOrEqual(t *testing.T) {
 func TestPrinterPrintBinaryGreater(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryGreater{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryGreater{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a>$b`
 	actual := o.String()
@@ -1002,15 +1028,16 @@ func TestPrinterPrintBinaryGreater(t *testing.T) {
 func TestPrinterPrintBinaryIdentical(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryIdentical{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryIdentical{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a===$b`
 	actual := o.String()
@@ -1023,17 +1050,18 @@ func TestPrinterPrintBinaryIdentical(t *testing.T) {
 func TestPrinterPrintBinaryLogicalAnd(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryLogicalAnd{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryLogicalAnd{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `$a and $b`
+	expected := `$a and$b`
 	actual := o.String()
 
 	if expected != actual {
@@ -1044,17 +1072,18 @@ func TestPrinterPrintBinaryLogicalAnd(t *testing.T) {
 func TestPrinterPrintBinaryLogicalOr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryLogicalOr{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryLogicalOr{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `$a or $b`
+	expected := `$a or$b`
 	actual := o.String()
 
 	if expected != actual {
@@ -1065,17 +1094,18 @@ func TestPrinterPrintBinaryLogicalOr(t *testing.T) {
 func TestPrinterPrintBinaryLogicalXor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryLogicalXor{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryLogicalXor{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `$a xor $b`
+	expected := `$a xor$b`
 	actual := o.String()
 
 	if expected != actual {
@@ -1086,15 +1116,16 @@ func TestPrinterPrintBinaryLogicalXor(t *testing.T) {
 func TestPrinterPrintBinaryMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryMinus{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryMinus{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a-$b`
 	actual := o.String()
@@ -1107,15 +1138,16 @@ func TestPrinterPrintBinaryMinus(t *testing.T) {
 func TestPrinterPrintBinaryMod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryMod{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryMod{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a%$b`
 	actual := o.String()
@@ -1128,15 +1160,16 @@ func TestPrinterPrintBinaryMod(t *testing.T) {
 func TestPrinterPrintBinaryMul(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryMul{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryMul{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a*$b`
 	actual := o.String()
@@ -1149,15 +1182,16 @@ func TestPrinterPrintBinaryMul(t *testing.T) {
 func TestPrinterPrintBinaryNotEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryNotEqual{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryNotEqual{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a!=$b`
 	actual := o.String()
@@ -1170,15 +1204,16 @@ func TestPrinterPrintBinaryNotEqual(t *testing.T) {
 func TestPrinterPrintBinaryNotIdentical(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryNotIdentical{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryNotIdentical{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a!==$b`
 	actual := o.String()
@@ -1191,15 +1226,16 @@ func TestPrinterPrintBinaryNotIdentical(t *testing.T) {
 func TestPrinterPrintBinaryPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryPlus{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryPlus{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a+$b`
 	actual := o.String()
@@ -1212,15 +1248,16 @@ func TestPrinterPrintBinaryPlus(t *testing.T) {
 func TestPrinterPrintBinaryPow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryPow{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryPow{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a**$b`
 	actual := o.String()
@@ -1233,15 +1270,16 @@ func TestPrinterPrintBinaryPow(t *testing.T) {
 func TestPrinterPrintBinaryShiftLeft(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryShiftLeft{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryShiftLeft{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a<<$b`
 	actual := o.String()
@@ -1254,15 +1292,16 @@ func TestPrinterPrintBinaryShiftLeft(t *testing.T) {
 func TestPrinterPrintBinaryShiftRight(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinaryShiftRight{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinaryShiftRight{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a>>$b`
 	actual := o.String()
@@ -1275,15 +1314,16 @@ func TestPrinterPrintBinaryShiftRight(t *testing.T) {
 func TestPrinterPrintBinarySmallerOrEqual(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinarySmallerOrEqual{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinarySmallerOrEqual{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a<=$b`
 	actual := o.String()
@@ -1296,15 +1336,16 @@ func TestPrinterPrintBinarySmallerOrEqual(t *testing.T) {
 func TestPrinterPrintBinarySmaller(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinarySmaller{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinarySmaller{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a<$b`
 	actual := o.String()
@@ -1317,15 +1358,16 @@ func TestPrinterPrintBinarySmaller(t *testing.T) {
 func TestPrinterPrintBinarySpaceship(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBinarySpaceship{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBinarySpaceship{
 		Left: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Right: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a<=>$b`
 	actual := o.String()
@@ -1340,12 +1382,13 @@ func TestPrinterPrintBinarySpaceship(t *testing.T) {
 func TestPrinterPrintArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastArray{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastArray{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `(array)$var`
 	actual := o.String()
@@ -1358,14 +1401,15 @@ func TestPrinterPrintArray(t *testing.T) {
 func TestPrinterPrintBool(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastBool{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastBool{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `(boolean)$var`
+	expected := `(bool)$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -1376,12 +1420,13 @@ func TestPrinterPrintBool(t *testing.T) {
 func TestPrinterPrintDouble(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastDouble{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastDouble{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `(float)$var`
 	actual := o.String()
@@ -1394,12 +1439,13 @@ func TestPrinterPrintDouble(t *testing.T) {
 func TestPrinterPrintInt(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastInt{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastInt{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `(integer)$var`
 	actual := o.String()
@@ -1412,12 +1458,13 @@ func TestPrinterPrintInt(t *testing.T) {
 func TestPrinterPrintObject(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastObject{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastObject{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `(object)$var`
 	actual := o.String()
@@ -1430,12 +1477,13 @@ func TestPrinterPrintObject(t *testing.T) {
 func TestPrinterPrintString(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastString{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastString{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `(string)$var`
 	actual := o.String()
@@ -1448,12 +1496,13 @@ func TestPrinterPrintString(t *testing.T) {
 func TestPrinterPrintUnset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprCastUnset{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprCastUnset{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `(unset)$var`
 	actual := o.String()
@@ -1468,13 +1517,14 @@ func TestPrinterPrintUnset(t *testing.T) {
 func TestPrinterPrintExprArrayDimFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprArrayDimFetch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprArrayDimFetch{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
 		Dim: &ast.ScalarLnumber{Value: []byte("1")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$var[1]`
 	actual := o.String()
@@ -1487,13 +1537,14 @@ func TestPrinterPrintExprArrayDimFetch(t *testing.T) {
 func TestPrinterPrintExprArrayItemWithKey(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprArrayItem{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprArrayItem{
 		Key: &ast.ScalarString{Value: []byte("'Hello'")},
 		Val: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$world")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `'Hello'=>$world`
 	actual := o.String()
@@ -1506,12 +1557,13 @@ func TestPrinterPrintExprArrayItemWithKey(t *testing.T) {
 func TestPrinterPrintExprArrayItem(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprArrayItem{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprArrayItem{
 		Val: &ast.ExprReference{Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$world")},
 		}},
-	})
+	}
+	n.Accept(p)
 
 	expected := `&$world`
 	actual := o.String()
@@ -1524,13 +1576,16 @@ func TestPrinterPrintExprArrayItem(t *testing.T) {
 func TestPrinterPrintExprArrayItemUnpack(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprArrayItem{
-		Unpack: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprArrayItem{
+		EllipsisTkn: &token.Token{
+			Value: []byte("..."),
+		},
 		Val: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$world")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `...$world`
 	actual := o.String()
@@ -1543,8 +1598,11 @@ func TestPrinterPrintExprArrayItemUnpack(t *testing.T) {
 func TestPrinterPrintExprArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprArray{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprArray{
+		ArrayTkn: &token.Token{
+			Value: []byte("array"),
+		},
 		Items: []ast.Vertex{
 			&ast.ExprArrayItem{
 				Key: &ast.ScalarString{Value: []byte("'Hello'")},
@@ -1564,7 +1622,8 @@ func TestPrinterPrintExprArray(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `array('Hello'=>$world,2=>&$var,$var)`
 	actual := o.String()
@@ -1577,12 +1636,13 @@ func TestPrinterPrintExprArray(t *testing.T) {
 func TestPrinterPrintExprBitwiseNot(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBitwiseNot{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBitwiseNot{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `~$var`
 	actual := o.String()
@@ -1595,12 +1655,13 @@ func TestPrinterPrintExprBitwiseNot(t *testing.T) {
 func TestPrinterPrintExprBooleanNot(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprBooleanNot{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprBooleanNot{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `!$var`
 	actual := o.String()
@@ -1613,15 +1674,16 @@ func TestPrinterPrintExprBooleanNot(t *testing.T) {
 func TestPrinterPrintExprClassConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprClassConstFetch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprClassConstFetch{
 		Class: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
 		ConstantName: &ast.Identifier{
 			Value: []byte("CONST"),
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$var::CONST`
 	actual := o.String()
@@ -1634,14 +1696,15 @@ func TestPrinterPrintExprClassConstFetch(t *testing.T) {
 func TestPrinterPrintExprClone(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprClone{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprClone{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `clone $var`
+	expected := `clone$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -1652,8 +1715,8 @@ func TestPrinterPrintExprClone(t *testing.T) {
 func TestPrinterPrintExprClosureUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprClosureUse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprClosureUse{
 		Uses: []ast.Vertex{
 			&ast.ExprReference{Var: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$foo")},
@@ -1662,7 +1725,8 @@ func TestPrinterPrintExprClosureUse(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$bar")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `use(&$foo,$bar)`
 	actual := o.String()
@@ -1675,16 +1739,18 @@ func TestPrinterPrintExprClosureUse(t *testing.T) {
 func TestPrinterPrintExprClosure(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprClosure{
-		Static:     true,
-		ReturnsRef: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprClosure{
+		StaticTkn: &token.Token{
+			Value: []byte("static"),
+		},
+		AmpersandTkn: &token.Token{
+			Value: []byte("&"),
+		},
 		Params: []ast.Vertex{
 			&ast.Parameter{
-				Var: &ast.Reference{
-					Var: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$var")},
-					},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$var")},
 				},
 			},
 		},
@@ -1706,9 +1772,10 @@ func TestPrinterPrintExprClosure(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			}},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `static function&(&$var)use(&$a,$b):\Foo{$a;}`
+	expected := `static function&($var)use(&$a,$b):\Foo{$a;}`
 	actual := o.String()
 
 	if expected != actual {
@@ -1719,17 +1786,22 @@ func TestPrinterPrintExprClosure(t *testing.T) {
 func TestPrinterPrintExprArrowFunction(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtExpression{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtExpression{
 		Expr: &ast.ExprArrowFunction{
-			Static:     true,
-			ReturnsRef: true,
+			StaticTkn: &token.Token{
+				Value: []byte("static"),
+			},
+			AmpersandTkn: &token.Token{
+				Value: []byte("&"),
+			},
 			Params: []ast.Vertex{
 				&ast.Parameter{
-					Var: &ast.Reference{
-						Var: &ast.ExprVariable{
-							VarName: &ast.Identifier{Value: []byte("$var")},
-						},
+					AmpersandTkn: &token.Token{
+						Value: []byte("&"),
+					},
+					Var: &ast.ExprVariable{
+						VarName: &ast.Identifier{Value: []byte("$var")},
 					},
 				},
 			},
@@ -1740,7 +1812,8 @@ func TestPrinterPrintExprArrowFunction(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `static fn&(&$var):\Foo=>$a;`
 	actual := o.String()
@@ -1753,10 +1826,11 @@ func TestPrinterPrintExprArrowFunction(t *testing.T) {
 func TestPrinterPrintExprConstFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprConstFetch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprConstFetch{
 		Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}},
-	})
+	}
+	n.Accept(p)
 
 	expected := "null"
 	actual := o.String()
@@ -1769,12 +1843,13 @@ func TestPrinterPrintExprConstFetch(t *testing.T) {
 func TestPrinterPrintEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprEmpty{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprEmpty{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `empty($var)`
 	actual := o.String()
@@ -1787,12 +1862,13 @@ func TestPrinterPrintEmpty(t *testing.T) {
 func TestPrinterPrettyPrinterrorSuppress(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprErrorSuppress{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprErrorSuppress{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `@$var`
 	actual := o.String()
@@ -1805,12 +1881,13 @@ func TestPrinterPrettyPrinterrorSuppress(t *testing.T) {
 func TestPrinterPrintEval(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprEval{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprEval{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `eval($var)`
 	actual := o.String()
@@ -1823,15 +1900,15 @@ func TestPrinterPrintEval(t *testing.T) {
 func TestPrinterPrintExit(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprExit{
-		Die: false,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprExit{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `exit $var`
+	expected := `exit$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -1842,15 +1919,18 @@ func TestPrinterPrintExit(t *testing.T) {
 func TestPrinterPrintDie(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprExit{
-		Die: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprExit{
+		DieTkn: &token.Token{
+			Value: []byte("die"),
+		},
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `die $var`
+	expected := `die$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -1861,33 +1941,36 @@ func TestPrinterPrintDie(t *testing.T) {
 func TestPrinterPrintFunctionCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprFunctionCall{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprFunctionCall{
 		Function: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-		ArgumentList: &ast.ArgumentList{
-			Arguments: []ast.Vertex{
-				&ast.Argument{
-					IsReference: true,
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$a")},
-					},
+		Arguments: []ast.Vertex{
+			&ast.Argument{
+				AmpersandTkn: &token.Token{
+					Value: []byte("&"),
 				},
-				&ast.Argument{
-					Variadic: true,
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
-				&ast.Argument{
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$c")},
-					},
+			},
+			&ast.Argument{
+				VariadicTkn: &token.Token{
+					Value: []byte("..."),
+				},
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
+				},
+			},
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$c")},
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$var(&$a,...$b,$c)`
 	actual := o.String()
@@ -1900,12 +1983,13 @@ func TestPrinterPrintFunctionCall(t *testing.T) {
 func TestPrinterPrintInclude(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprInclude{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprInclude{
 		Expr: &ast.ScalarString{Value: []byte("'path'")},
-	})
+	}
+	n.Accept(p)
 
-	expected := `include 'path'`
+	expected := `include'path'`
 	actual := o.String()
 
 	if expected != actual {
@@ -1916,12 +2000,13 @@ func TestPrinterPrintInclude(t *testing.T) {
 func TestPrinterPrintIncludeOnce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprIncludeOnce{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprIncludeOnce{
 		Expr: &ast.ScalarString{Value: []byte("'path'")},
-	})
+	}
+	n.Accept(p)
 
-	expected := `include_once 'path'`
+	expected := `include_once'path'`
 	actual := o.String()
 
 	if expected != actual {
@@ -1932,13 +2017,14 @@ func TestPrinterPrintIncludeOnce(t *testing.T) {
 func TestPrinterPrintInstanceOf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprInstanceOf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprInstanceOf{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
 		Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$var instanceof Foo`
 	actual := o.String()
@@ -1951,8 +2037,8 @@ func TestPrinterPrintInstanceOf(t *testing.T) {
 func TestPrinterPrintIsset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprIsset{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprIsset{
 		Vars: []ast.Vertex{
 			&ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -1961,7 +2047,8 @@ func TestPrinterPrintIsset(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$b")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `isset($a,$b)`
 	actual := o.String()
@@ -1974,8 +2061,8 @@ func TestPrinterPrintIsset(t *testing.T) {
 func TestPrinterPrintList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprList{
 		Items: []ast.Vertex{
 			&ast.ExprArrayItem{
 				Val: &ast.ExprVariable{
@@ -1999,7 +2086,8 @@ func TestPrinterPrintList(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `list($a,list($b,$c))`
 	actual := o.String()
@@ -2012,27 +2100,26 @@ func TestPrinterPrintList(t *testing.T) {
 func TestPrinterPrintMethodCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprMethodCall{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &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")},
-					},
+		Arguments: []ast.Vertex{
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
-				&ast.Argument{
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+			},
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$foo->bar($a,$b)`
 	actual := o.String()
@@ -2045,8 +2132,8 @@ func TestPrinterPrintMethodCall(t *testing.T) {
 func TestPrinterPrintNew(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprNew{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprNew{
 		Class: &ast.NameName{
 			Parts: []ast.Vertex{
 				&ast.NameNamePart{
@@ -2054,21 +2141,20 @@ func TestPrinterPrintNew(t *testing.T) {
 				},
 			},
 		},
-		ArgumentList: &ast.ArgumentList{
-			Arguments: []ast.Vertex{
-				&ast.Argument{
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$a")},
-					},
+		Arguments: []ast.Vertex{
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
-				&ast.Argument{
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+			},
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `new Foo($a,$b)`
 	actual := o.String()
@@ -2081,12 +2167,13 @@ func TestPrinterPrintNew(t *testing.T) {
 func TestPrinterPrintPostDec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprPostDec{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprPostDec{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$var--`
 	actual := o.String()
@@ -2099,12 +2186,13 @@ func TestPrinterPrintPostDec(t *testing.T) {
 func TestPrinterPrintPostInc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprPostInc{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprPostInc{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$var++`
 	actual := o.String()
@@ -2117,12 +2205,13 @@ func TestPrinterPrintPostInc(t *testing.T) {
 func TestPrinterPrintPreDec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprPreDec{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprPreDec{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `--$var`
 	actual := o.String()
@@ -2135,12 +2224,13 @@ func TestPrinterPrintPreDec(t *testing.T) {
 func TestPrinterPrintPreInc(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprPreInc{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprPreInc{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `++$var`
 	actual := o.String()
@@ -2153,14 +2243,15 @@ func TestPrinterPrintPreInc(t *testing.T) {
 func TestPrinterPrintPrint(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprPrint{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprPrint{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `print $var`
+	expected := `print$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -2171,13 +2262,14 @@ func TestPrinterPrintPrint(t *testing.T) {
 func TestPrinterPrintPropertyFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprPropertyFetch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprPropertyFetch{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$foo")},
 		},
 		Property: &ast.Identifier{Value: []byte("bar")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$foo->bar`
 	actual := o.String()
@@ -2190,12 +2282,13 @@ func TestPrinterPrintPropertyFetch(t *testing.T) {
 func TestPrinterPrintExprReference(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprReference{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprReference{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$foo")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `&$foo`
 	actual := o.String()
@@ -2208,12 +2301,13 @@ func TestPrinterPrintExprReference(t *testing.T) {
 func TestPrinterPrintRequire(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprRequire{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprRequire{
 		Expr: &ast.ScalarString{Value: []byte("'path'")},
-	})
+	}
+	n.Accept(p)
 
-	expected := `require 'path'`
+	expected := `require'path'`
 	actual := o.String()
 
 	if expected != actual {
@@ -2224,12 +2318,13 @@ func TestPrinterPrintRequire(t *testing.T) {
 func TestPrinterPrintRequireOnce(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprRequireOnce{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprRequireOnce{
 		Expr: &ast.ScalarString{Value: []byte("'path'")},
-	})
+	}
+	n.Accept(p)
 
-	expected := `require_once 'path'`
+	expected := `require_once'path'`
 	actual := o.String()
 
 	if expected != actual {
@@ -2240,8 +2335,8 @@ func TestPrinterPrintRequireOnce(t *testing.T) {
 func TestPrinterPrintShellExec(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprShellExec{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprShellExec{
 		Parts: []ast.Vertex{
 			&ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
 			&ast.ExprVariable{
@@ -2249,7 +2344,8 @@ func TestPrinterPrintShellExec(t *testing.T) {
 			},
 			&ast.ScalarEncapsedStringPart{Value: []byte("!")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "`hello $world!`"
 	actual := o.String()
@@ -2262,8 +2358,8 @@ func TestPrinterPrintShellExec(t *testing.T) {
 func TestPrinterPrintExprShortArray(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprShortArray{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprArray{
 		Items: []ast.Vertex{
 			&ast.ExprArrayItem{
 				Key: &ast.ScalarString{Value: []byte("'Hello'")},
@@ -2283,7 +2379,8 @@ func TestPrinterPrintExprShortArray(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `['Hello'=>$world,2=>&$var,$var]`
 	actual := o.String()
@@ -2296,8 +2393,11 @@ func TestPrinterPrintExprShortArray(t *testing.T) {
 func TestPrinterPrintShortList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprShortList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprList{
+		OpenBracketTkn: &token.Token{
+			Value: []byte("["),
+		},
 		Items: []ast.Vertex{
 			&ast.ExprArrayItem{
 				Val: &ast.ExprVariable{
@@ -2321,7 +2421,11 @@ func TestPrinterPrintShortList(t *testing.T) {
 				},
 			},
 		},
-	})
+		CloseBracketTkn: &token.Token{
+			Value: []byte("]"),
+		},
+	}
+	n.Accept(p)
 
 	expected := `[$a,list($b,$c)]`
 	actual := o.String()
@@ -2334,25 +2438,24 @@ func TestPrinterPrintShortList(t *testing.T) {
 func TestPrinterPrintStaticCall(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprStaticCall{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &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")},
-					},
+		Arguments: []ast.Vertex{
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
-				&ast.Argument{
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+			},
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `Foo::bar($a,$b)`
 	actual := o.String()
@@ -2365,13 +2468,14 @@ func TestPrinterPrintStaticCall(t *testing.T) {
 func TestPrinterPrintStaticPropertyFetch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprStaticPropertyFetch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprStaticPropertyFetch{
 		Class: &ast.Identifier{Value: []byte("Foo")},
 		Property: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$bar")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `Foo::$bar`
 	actual := o.String()
@@ -2384,15 +2488,16 @@ func TestPrinterPrintStaticPropertyFetch(t *testing.T) {
 func TestPrinterPrintTernary(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprTernary{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprTernary{
 		Condition: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		IfFalse: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$b")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a?:$b`
 	actual := o.String()
@@ -2405,8 +2510,8 @@ func TestPrinterPrintTernary(t *testing.T) {
 func TestPrinterPrintTernaryFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprTernary{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprTernary{
 		Condition: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -2416,7 +2521,8 @@ func TestPrinterPrintTernaryFull(t *testing.T) {
 		IfFalse: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$c")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a?$b:$c`
 	actual := o.String()
@@ -2429,12 +2535,13 @@ func TestPrinterPrintTernaryFull(t *testing.T) {
 func TestPrinterPrintUnaryMinus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprUnaryMinus{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprUnaryMinus{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `-$var`
 	actual := o.String()
@@ -2447,12 +2554,13 @@ func TestPrinterPrintUnaryMinus(t *testing.T) {
 func TestPrinterPrintUnaryPlus(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprUnaryPlus{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprUnaryPlus{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `+$var`
 	actual := o.String()
@@ -2465,12 +2573,16 @@ func TestPrinterPrintUnaryPlus(t *testing.T) {
 func TestPrinterPrintVariable(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprVariable{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprVariable{
+		DollarTkn: &token.Token{
+			Value: []byte("$"),
+		},
 		VarName: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$$var`
 	actual := o.String()
@@ -2483,14 +2595,15 @@ func TestPrinterPrintVariable(t *testing.T) {
 func TestPrinterPrintYieldFrom(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprYieldFrom{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprYieldFrom{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `yield from $var`
+	expected := `yield from$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -2501,14 +2614,15 @@ func TestPrinterPrintYieldFrom(t *testing.T) {
 func TestPrinterPrintYield(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprYield{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprYield{
 		Value: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `yield $var`
+	expected := `yield$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -2519,17 +2633,18 @@ func TestPrinterPrintYield(t *testing.T) {
 func TestPrinterPrintYieldFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.ExprYield{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.ExprYield{
 		Key: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$k")},
 		},
 		Value: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `yield $k=>$var`
+	expected := `yield$k=>$var`
 	actual := o.String()
 
 	if expected != actual {
@@ -2542,12 +2657,14 @@ func TestPrinterPrintYieldFull(t *testing.T) {
 func TestPrinterPrintAltElseIf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElseIf{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElseIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2555,7 +2672,8 @@ func TestPrinterPrintAltElseIf(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `elseif($a):$b;`
 	actual := o.String()
@@ -2568,14 +2686,17 @@ func TestPrinterPrintAltElseIf(t *testing.T) {
 func TestPrinterPrintAltElseIfEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElseIf{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElseIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{},
-	})
+	}
+	n.Accept(p)
 
 	expected := `elseif($a):`
 	actual := o.String()
@@ -2588,9 +2709,11 @@ func TestPrinterPrintAltElseIfEmpty(t *testing.T) {
 func TestPrinterPrintAltElse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElse{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElse{
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2598,7 +2721,8 @@ func TestPrinterPrintAltElse(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `else:$b;`
 	actual := o.String()
@@ -2611,11 +2735,14 @@ func TestPrinterPrintAltElse(t *testing.T) {
 func TestPrinterPrintAltElseEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElse{
-		Alt:  true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElse{
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{},
-	})
+	}
+	n.Accept(p)
 
 	expected := `else:`
 	actual := o.String()
@@ -2628,9 +2755,8 @@ func TestPrinterPrintAltElseEmpty(t *testing.T) {
 func TestPrinterPrintAltFor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtFor{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtFor{
 		Init: []ast.Vertex{
 			&ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -2646,6 +2772,9 @@ func TestPrinterPrintAltFor(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$c")},
 			},
 		},
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2653,7 +2782,8 @@ func TestPrinterPrintAltFor(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `for($a;$b;$c):$d;endfor;`
 	actual := o.String()
@@ -2666,18 +2796,22 @@ func TestPrinterPrintAltFor(t *testing.T) {
 func TestPrinterPrintAltForeach(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtForeach{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtForeach{
 		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")},
-		}},
+		Var: &ast.ExprReference{
+			Var: &ast.ExprVariable{
+				VarName: &ast.Identifier{Value: []byte("$val")},
+			},
+		},
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2685,9 +2819,10 @@ func TestPrinterPrintAltForeach(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `foreach($var as $key=>&$val):$d;endforeach;`
+	expected := `foreach($var as$key=>&$val):$d;endforeach;`
 	actual := o.String()
 
 	if expected != actual {
@@ -2698,12 +2833,14 @@ func TestPrinterPrintAltForeach(t *testing.T) {
 func TestPrinterPrintAltIf(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtIf{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2713,10 +2850,12 @@ func TestPrinterPrintAltIf(t *testing.T) {
 		},
 		ElseIf: []ast.Vertex{
 			&ast.StmtElseIf{
-				Alt: true,
 				Cond: &ast.ExprVariable{
 					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
+				ColonTkn: &token.Token{
+					Value: []byte(":"),
+				},
 				Stmt: &ast.StmtStmtList{
 					Stmts: []ast.Vertex{
 						&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2726,15 +2865,19 @@ func TestPrinterPrintAltIf(t *testing.T) {
 				},
 			},
 			&ast.StmtElseIf{
-				Alt: true,
 				Cond: &ast.ExprVariable{
 					VarName: &ast.Identifier{Value: []byte("$c")},
 				},
+				ColonTkn: &token.Token{
+					Value: []byte(":"),
+				},
 				Stmt: &ast.StmtStmtList{},
 			},
 		},
 		Else: &ast.StmtElse{
-			Alt: true,
+			ColonTkn: &token.Token{
+				Value: []byte(":"),
+			},
 			Stmt: &ast.StmtStmtList{
 				Stmts: []ast.Vertex{
 					&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2743,7 +2886,8 @@ func TestPrinterPrintAltIf(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `if($a):$d;elseif($b):$b;elseif($c):else:$b;endif;`
 	actual := o.String()
@@ -2756,12 +2900,14 @@ func TestPrinterPrintAltIf(t *testing.T) {
 func TestPrinterPrintStmtAltSwitch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtSwitch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtSwitch{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-		Alt: true,
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		CaseList: []ast.Vertex{
 			&ast.StmtCase{
 				Cond: &ast.ScalarString{Value: []byte("'a'")},
@@ -2780,9 +2926,10 @@ func TestPrinterPrintStmtAltSwitch(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `switch($var):case 'a':$a;case 'b':$b;endswitch;`
+	expected := `switch($var):case'a':$a;case'b':$b;endswitch;`
 	actual := o.String()
 
 	if expected != actual {
@@ -2793,12 +2940,14 @@ func TestPrinterPrintStmtAltSwitch(t *testing.T) {
 func TestPrinterPrintAltWhile(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtWhile{
-		Alt: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtWhile{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
+		ColonTkn: &token.Token{
+			Value: []byte(":"),
+		},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtExpression{Expr: &ast.ExprVariable{
@@ -2806,7 +2955,8 @@ func TestPrinterPrintAltWhile(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `while($a):$b;endwhile;`
 	actual := o.String()
@@ -2819,12 +2969,13 @@ func TestPrinterPrintAltWhile(t *testing.T) {
 func TestPrinterPrintStmtBreak(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtBreak{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtBreak{
 		Expr: &ast.ScalarLnumber{
 			Value: []byte("1"),
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := "break 1;"
 	actual := o.String()
@@ -2837,8 +2988,8 @@ func TestPrinterPrintStmtBreak(t *testing.T) {
 func TestPrinterPrintStmtCase(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtCase{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtCase{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -2847,9 +2998,10 @@ func TestPrinterPrintStmtCase(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			}},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `case $a:$a;`
+	expected := `case$a:$a;`
 	actual := o.String()
 
 	if expected != actual {
@@ -2860,15 +3012,16 @@ func TestPrinterPrintStmtCase(t *testing.T) {
 func TestPrinterPrintStmtCaseEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtCase{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtCase{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Stmts: []ast.Vertex{},
-	})
+	}
+	n.Accept(p)
 
-	expected := "case $a:"
+	expected := "case$a:"
 	actual := o.String()
 
 	if expected != actual {
@@ -2879,8 +3032,8 @@ func TestPrinterPrintStmtCaseEmpty(t *testing.T) {
 func TestPrinterPrintStmtCatch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtCatch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &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")}}},
@@ -2893,7 +3046,8 @@ func TestPrinterPrintStmtCatch(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			}},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `catch(Exception|\RuntimeException$e){$a;}`
 	actual := o.String()
@@ -2906,26 +3060,30 @@ func TestPrinterPrintStmtCatch(t *testing.T) {
 func TestPrinterPrintStmtClassMethod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtClassMethod{
-		Modifiers:  []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
-		ReturnsRef: true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtClassMethod{
+		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+		AmpersandTkn: &token.Token{
+			Value: []byte("&"),
+		},
 		MethodName: &ast.Identifier{Value: []byte("foo")},
 		Params: []ast.Vertex{
 			&ast.Parameter{
 				Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
-				Var: &ast.Reference{
-					Var: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$a")},
-					},
+				AmpersandTkn: &token.Token{
+					Value: []byte("&"),
+				},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
 				DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
 			},
 			&ast.Parameter{
-				Var: &ast.Variadic{
-					Var: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+				VariadicTkn: &token.Token{
+					Value: []byte("..."),
+				},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
 			},
 		},
@@ -2939,9 +3097,10 @@ func TestPrinterPrintStmtClassMethod(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `public function &foo(?int&$a=null,...$b):void{$a;}`
+	expected := `public function&foo(?int&$a=null,...$b):void{$a;}`
 	actual := o.String()
 
 	if expected != actual {
@@ -2952,29 +3111,33 @@ func TestPrinterPrintStmtClassMethod(t *testing.T) {
 func TestPrinterPrintStmtAbstractClassMethod(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtClassMethod{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtClassMethod{
 		Modifiers: []ast.Vertex{
 			&ast.Identifier{Value: []byte("public")},
 			&ast.Identifier{Value: []byte("static")},
 		},
-		ReturnsRef: true,
+		AmpersandTkn: &token.Token{
+			Value: []byte("&"),
+		},
 		MethodName: &ast.Identifier{Value: []byte("foo")},
 		Params: []ast.Vertex{
 			&ast.Parameter{
 				Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
-				Var: &ast.Reference{
-					Var: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$a")},
-					},
+				AmpersandTkn: &token.Token{
+					Value: []byte("&"),
+				},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
 				DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
 			},
 			&ast.Parameter{
-				Var: &ast.Variadic{
-					Var: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+				VariadicTkn: &token.Token{
+					Value: []byte("..."),
+				},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
 			},
 		},
@@ -2982,9 +3145,10 @@ func TestPrinterPrintStmtAbstractClassMethod(t *testing.T) {
 			Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}},
 		},
 		Stmt: &ast.StmtNop{},
-	})
+	}
+	n.Accept(p)
 
-	expected := `public static function &foo(?int&$a=null,...$b):void;`
+	expected := `public static function&foo(?int&$a=null,...$b):void;`
 	actual := o.String()
 
 	if expected != actual {
@@ -2995,8 +3159,8 @@ func TestPrinterPrintStmtAbstractClassMethod(t *testing.T) {
 func TestPrinterPrintStmtClass(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtClass{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtClass{
 		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
 		ClassName: &ast.Identifier{Value: []byte("Foo")},
 		Extends: &ast.StmtClassExtends{
@@ -3022,7 +3186,8 @@ func TestPrinterPrintStmtClass(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `abstract class Foo extends Bar implements Baz,Quuz{public static const FOO='bar';}`
 	actual := o.String()
@@ -3035,20 +3200,18 @@ func TestPrinterPrintStmtClass(t *testing.T) {
 func TestPrinterPrintStmtAnonymousClass(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtClass{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &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")},
-					},
+		Arguments: []ast.Vertex{
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$a")},
 				},
-				&ast.Argument{
-					Expr: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$b")},
-					},
+			},
+			&ast.Argument{
+				Expr: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$b")},
 				},
 			},
 		},
@@ -3072,9 +3235,10 @@ func TestPrinterPrintStmtAnonymousClass(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `abstract class($a,$b) extends Bar implements Baz,Quuz{public const FOO='bar';}`
+	expected := `abstract class($a,$b)extends Bar implements Baz,Quuz{public const FOO='bar';}`
 	actual := o.String()
 
 	if expected != actual {
@@ -3085,8 +3249,8 @@ func TestPrinterPrintStmtAnonymousClass(t *testing.T) {
 func TestPrinterPrintStmtClassConstList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtClassConstList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtClassConstList{
 		Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
 		Consts: []ast.Vertex{
 			&ast.StmtConstant{
@@ -3098,7 +3262,8 @@ func TestPrinterPrintStmtClassConstList(t *testing.T) {
 				Expr: &ast.ScalarString{Value: []byte("'b'")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `public const FOO='a',BAR='b';`
 	actual := o.String()
@@ -3111,8 +3276,8 @@ func TestPrinterPrintStmtClassConstList(t *testing.T) {
 func TestPrinterPrintStmtConstList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtConstList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtConstList{
 		Consts: []ast.Vertex{
 			&ast.StmtConstant{
 				Name: &ast.Identifier{Value: []byte("FOO")},
@@ -3123,7 +3288,8 @@ func TestPrinterPrintStmtConstList(t *testing.T) {
 				Expr: &ast.ScalarString{Value: []byte("'b'")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `const FOO='a',BAR='b';`
 	actual := o.String()
@@ -3136,11 +3302,12 @@ func TestPrinterPrintStmtConstList(t *testing.T) {
 func TestPrinterPrintStmtConstant(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtConstant{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtConstant{
 		Name: &ast.Identifier{Value: []byte("FOO")},
 		Expr: &ast.ScalarString{Value: []byte("'BAR'")},
-	})
+	}
+	n.Accept(p)
 
 	expected := "FOO='BAR'"
 	actual := o.String()
@@ -3153,12 +3320,13 @@ func TestPrinterPrintStmtConstant(t *testing.T) {
 func TestPrinterPrintStmtContinue(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtContinue{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtContinue{
 		Expr: &ast.ScalarLnumber{
 			Value: []byte("1"),
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `continue 1;`
 	actual := o.String()
@@ -3171,8 +3339,8 @@ func TestPrinterPrintStmtContinue(t *testing.T) {
 func TestPrinterPrintStmtDeclareStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDeclare{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDeclare{
 		Consts: []ast.Vertex{
 			&ast.StmtConstant{
 				Name: &ast.Identifier{Value: []byte("FOO")},
@@ -3184,7 +3352,8 @@ func TestPrinterPrintStmtDeclareStmts(t *testing.T) {
 				&ast.StmtNop{},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `declare(FOO='bar'){;}`
 	actual := o.String()
@@ -3197,8 +3366,8 @@ func TestPrinterPrintStmtDeclareStmts(t *testing.T) {
 func TestPrinterPrintStmtDeclareExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDeclare{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDeclare{
 		Consts: []ast.Vertex{
 			&ast.StmtConstant{
 				Name: &ast.Identifier{Value: []byte("FOO")},
@@ -3206,7 +3375,8 @@ func TestPrinterPrintStmtDeclareExpr(t *testing.T) {
 			},
 		},
 		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
-	})
+	}
+	n.Accept(p)
 
 	expected := `declare(FOO='bar')'bar';`
 	actual := o.String()
@@ -3219,8 +3389,8 @@ func TestPrinterPrintStmtDeclareExpr(t *testing.T) {
 func TestPrinterPrintStmtDeclareNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDeclare{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDeclare{
 		Consts: []ast.Vertex{
 			&ast.StmtConstant{
 				Name: &ast.Identifier{Value: []byte("FOO")},
@@ -3228,7 +3398,8 @@ func TestPrinterPrintStmtDeclareNop(t *testing.T) {
 			},
 		},
 		Stmt: &ast.StmtNop{},
-	})
+	}
+	n.Accept(p)
 
 	expected := `declare(FOO='bar');`
 	actual := o.String()
@@ -3241,14 +3412,15 @@ func TestPrinterPrintStmtDeclareNop(t *testing.T) {
 func TestPrinterPrintStmtDefalut(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDefault{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDefault{
 		Stmts: []ast.Vertex{
 			&ast.StmtExpression{Expr: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			}},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `default:$a;`
 	actual := o.String()
@@ -3261,10 +3433,11 @@ func TestPrinterPrintStmtDefalut(t *testing.T) {
 func TestPrinterPrintStmtDefalutEmpty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDefault{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDefault{
 		Stmts: []ast.Vertex{},
-	})
+	}
+	n.Accept(p)
 
 	expected := `default:`
 	actual := o.String()
@@ -3277,17 +3450,18 @@ func TestPrinterPrintStmtDefalutEmpty(t *testing.T) {
 func TestPrinterPrintStmtDo_Expression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDo{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDo{
 		Cond: &ast.ScalarLnumber{Value: []byte("1")},
 		Stmt: &ast.StmtExpression{
 			Expr: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `do $a;while(1);`
+	expected := `do$a;while(1);`
 	actual := o.String()
 
 	if expected != actual {
@@ -3298,8 +3472,8 @@ func TestPrinterPrintStmtDo_Expression(t *testing.T) {
 func TestPrinterPrintStmtDo_StmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtDo{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtDo{
 		Cond: &ast.ScalarLnumber{Value: []byte("1")},
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
@@ -3308,9 +3482,10 @@ func TestPrinterPrintStmtDo_StmtList(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `do {$a;}while(1);`
+	expected := `do{$a;}while(1);`
 	actual := o.String()
 
 	if expected != actual {
@@ -3321,8 +3496,8 @@ func TestPrinterPrintStmtDo_StmtList(t *testing.T) {
 func TestPrinterPrintStmtEchoHtmlState(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Root{
+	p := visitor.NewPrinter(o)
+	n := &ast.Root{
 		Stmts: []ast.Vertex{
 			&ast.StmtEcho{
 				Exprs: []ast.Vertex{
@@ -3335,9 +3510,10 @@ func TestPrinterPrintStmtEchoHtmlState(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `<?php echo $a,$b;`
+	expected := `<?php echo$a,$b;`
 	actual := o.String()
 
 	if expected != actual {
@@ -3348,8 +3524,8 @@ func TestPrinterPrintStmtEchoHtmlState(t *testing.T) {
 func TestPrinterPrintStmtEchoPhpState(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtEcho{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtEcho{
 		Exprs: []ast.Vertex{
 			&ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -3358,9 +3534,10 @@ func TestPrinterPrintStmtEchoPhpState(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$b")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `echo $a,$b;`
+	expected := `echo$a,$b;`
 	actual := o.String()
 
 	if expected != actual {
@@ -3371,8 +3548,8 @@ func TestPrinterPrintStmtEchoPhpState(t *testing.T) {
 func TestPrinterPrintStmtElseIfStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElseIf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElseIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -3381,7 +3558,8 @@ func TestPrinterPrintStmtElseIfStmts(t *testing.T) {
 				&ast.StmtNop{},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `elseif($a){;}`
 	actual := o.String()
@@ -3394,13 +3572,14 @@ func TestPrinterPrintStmtElseIfStmts(t *testing.T) {
 func TestPrinterPrintStmtElseIfExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElseIf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElseIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
-	})
+	}
+	n.Accept(p)
 
 	expected := `elseif($a)'bar';`
 	actual := o.String()
@@ -3413,13 +3592,14 @@ func TestPrinterPrintStmtElseIfExpr(t *testing.T) {
 func TestPrinterPrintStmtElseIfNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElseIf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElseIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Stmt: &ast.StmtNop{},
-	})
+	}
+	n.Accept(p)
 
 	expected := `elseif($a);`
 	actual := o.String()
@@ -3432,16 +3612,17 @@ func TestPrinterPrintStmtElseIfNop(t *testing.T) {
 func TestPrinterPrintStmtElseStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElse{
 		Stmt: &ast.StmtStmtList{
 			Stmts: []ast.Vertex{
 				&ast.StmtNop{},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `else {;}`
+	expected := `else{;}`
 	actual := o.String()
 
 	if expected != actual {
@@ -3452,12 +3633,13 @@ func TestPrinterPrintStmtElseStmts(t *testing.T) {
 func TestPrinterPrintStmtElseExpr(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElse{
 		Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
-	})
+	}
+	n.Accept(p)
 
-	expected := `else 'bar';`
+	expected := `else'bar';`
 	actual := o.String()
 
 	if expected != actual {
@@ -3468,12 +3650,13 @@ func TestPrinterPrintStmtElseExpr(t *testing.T) {
 func TestPrinterPrintStmtElseNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtElse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtElse{
 		Stmt: &ast.StmtNop{},
-	})
+	}
+	n.Accept(p)
 
-	expected := `else ;`
+	expected := `else;`
 	actual := o.String()
 
 	if expected != actual {
@@ -3484,12 +3667,13 @@ func TestPrinterPrintStmtElseNop(t *testing.T) {
 func TestPrinterPrintExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtExpression{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtExpression{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a;`
 	actual := o.String()
@@ -3502,12 +3686,13 @@ func TestPrinterPrintExpression(t *testing.T) {
 func TestPrinterPrintStmtFinally(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtFinally{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtFinally{
 		Stmts: []ast.Vertex{
 			&ast.StmtNop{},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `finally{;}`
 	actual := o.String()
@@ -3520,8 +3705,8 @@ func TestPrinterPrintStmtFinally(t *testing.T) {
 func TestPrinterPrintStmtFor(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtFor{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtFor{
 		Init: []ast.Vertex{
 			&ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -3551,7 +3736,8 @@ func TestPrinterPrintStmtFor(t *testing.T) {
 				&ast.StmtNop{},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `for($a,$b;$c,$d;$e,$f){;}`
 	actual := o.String()
@@ -3564,8 +3750,8 @@ func TestPrinterPrintStmtFor(t *testing.T) {
 func TestPrinterPrintStmtForeach(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtForeach{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtForeach{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -3580,9 +3766,10 @@ func TestPrinterPrintStmtForeach(t *testing.T) {
 				&ast.StmtNop{},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `foreach($a as $k=>$v){;}`
+	expected := `foreach($a as$k=>$v){;}`
 	actual := o.String()
 
 	if expected != actual {
@@ -3593,16 +3780,19 @@ func TestPrinterPrintStmtForeach(t *testing.T) {
 func TestPrinterPrintStmtFunction(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtFunction{
-		ReturnsRef:   true,
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtFunction{
+		AmpersandTkn: &token.Token{
+			Value: []byte("&"),
+		},
 		FunctionName: &ast.Identifier{Value: []byte("foo")},
 		Params: []ast.Vertex{
 			&ast.Parameter{
-				Var: &ast.Reference{
-					Var: &ast.ExprVariable{
-						VarName: &ast.Identifier{Value: []byte("$var")},
-					},
+				AmpersandTkn: &token.Token{
+					Value: []byte("&"),
+				},
+				Var: &ast.ExprVariable{
+					VarName: &ast.Identifier{Value: []byte("$var")},
 				},
 			},
 		},
@@ -3612,9 +3802,10 @@ func TestPrinterPrintStmtFunction(t *testing.T) {
 		Stmts: []ast.Vertex{
 			&ast.StmtNop{},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `function &foo(&$var):\Foo{;}`
+	expected := `function&foo(&$var):\Foo{;}`
 	actual := o.String()
 
 	if expected != actual {
@@ -3625,8 +3816,8 @@ func TestPrinterPrintStmtFunction(t *testing.T) {
 func TestPrinterPrintStmtGlobal(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtGlobal{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtGlobal{
 		Vars: []ast.Vertex{
 			&ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -3635,9 +3826,10 @@ func TestPrinterPrintStmtGlobal(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$b")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `global $a,$b;`
+	expected := `global$a,$b;`
 	actual := o.String()
 
 	if expected != actual {
@@ -3648,10 +3840,11 @@ func TestPrinterPrintStmtGlobal(t *testing.T) {
 func TestPrinterPrintStmtGoto(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtGoto{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtGoto{
 		Label: &ast.Identifier{Value: []byte("FOO")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `goto FOO;`
 	actual := o.String()
@@ -3664,8 +3857,9 @@ func TestPrinterPrintStmtGoto(t *testing.T) {
 func TestPrinterPrintHaltCompiler(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtHaltCompiler{})
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtHaltCompiler{}
+	n.Accept(p)
 
 	expected := `__halt_compiler();`
 	actual := o.String()
@@ -3678,8 +3872,8 @@ func TestPrinterPrintHaltCompiler(t *testing.T) {
 func TestPrinterPrintIfExpression(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtIf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -3717,9 +3911,10 @@ func TestPrinterPrintIfExpression(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `if($a)$b;elseif($c){$d;}elseif($e);else $f;`
+	expected := `if($a)$b;elseif($c){$d;}elseif($e);else$f;`
 	actual := o.String()
 
 	if expected != actual {
@@ -3730,8 +3925,8 @@ func TestPrinterPrintIfExpression(t *testing.T) {
 func TestPrinterPrintIfStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtIf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -3744,7 +3939,8 @@ func TestPrinterPrintIfStmtList(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `if($a){$b;}`
 	actual := o.String()
@@ -3757,13 +3953,14 @@ func TestPrinterPrintIfStmtList(t *testing.T) {
 func TestPrinterPrintIfNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtIf{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtIf{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Stmt: &ast.StmtNop{},
-	})
+	}
+	n.Accept(p)
 
 	expected := `if($a);`
 	actual := o.String()
@@ -3776,14 +3973,15 @@ func TestPrinterPrintIfNop(t *testing.T) {
 func TestPrinterPrintInlineHtml(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.Root{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.Root{
 		Stmts: []ast.Vertex{
 			&ast.StmtInlineHtml{
 				Value: []byte("test"),
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `test`
 	actual := o.String()
@@ -3796,8 +3994,8 @@ func TestPrinterPrintInlineHtml(t *testing.T) {
 func TestPrinterPrintInterface(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtInterface{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtInterface{
 		InterfaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 		Extends: &ast.StmtInterfaceExtends{
 			InterfaceNames: []ast.Vertex{
@@ -3819,7 +4017,8 @@ func TestPrinterPrintInterface(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `interface Foo extends Bar,Baz{public function foo(){$a;}}`
 	actual := o.String()
@@ -3832,10 +4031,11 @@ func TestPrinterPrintInterface(t *testing.T) {
 func TestPrinterPrintLabel(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtLabel{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtLabel{
 		LabelName: &ast.Identifier{Value: []byte("FOO")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `FOO:`
 	actual := o.String()
@@ -3848,10 +4048,11 @@ func TestPrinterPrintLabel(t *testing.T) {
 func TestPrinterPrintNamespace(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtNamespace{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtNamespace{
 		Name: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
-	})
+	}
+	n.Accept(p)
 
 	expected := `namespace Foo;`
 	actual := o.String()
@@ -3864,15 +4065,16 @@ func TestPrinterPrintNamespace(t *testing.T) {
 func TestPrinterPrintNamespaceWithStmts(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtNamespace{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtNamespace{
 		Name: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 		Stmts: []ast.Vertex{
 			&ast.StmtExpression{Expr: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
 			}},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `namespace Foo{$a;}`
 	actual := o.String()
@@ -3885,8 +4087,9 @@ func TestPrinterPrintNamespaceWithStmts(t *testing.T) {
 func TestPrinterPrintNop(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtNop{})
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtNop{}
+	n.Accept(p)
 
 	expected := `;`
 	actual := o.String()
@@ -3899,8 +4102,8 @@ func TestPrinterPrintNop(t *testing.T) {
 func TestPrinterPrintPropertyList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtPropertyList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtPropertyList{
 		Modifiers: []ast.Vertex{
 			&ast.Identifier{Value: []byte("public")},
 			&ast.Identifier{Value: []byte("static")},
@@ -3925,9 +4128,10 @@ func TestPrinterPrintPropertyList(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `public static Foo $a='a',$b;`
+	expected := `public static Foo$a='a',$b;`
 	actual := o.String()
 
 	if expected != actual {
@@ -3938,13 +4142,14 @@ func TestPrinterPrintPropertyList(t *testing.T) {
 func TestPrinterPrintProperty(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtProperty{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtProperty{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ScalarLnumber{Value: []byte("1")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a=1`
 	actual := o.String()
@@ -3957,10 +4162,11 @@ func TestPrinterPrintProperty(t *testing.T) {
 func TestPrinterPrintReturn(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtReturn{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtReturn{
 		Expr: &ast.ScalarLnumber{Value: []byte("1")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `return 1;`
 	actual := o.String()
@@ -3973,13 +4179,14 @@ func TestPrinterPrintReturn(t *testing.T) {
 func TestPrinterPrintStaticVar(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtStaticVar{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtStaticVar{
 		Var: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
 		Expr: &ast.ScalarLnumber{Value: []byte("1")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `$a=1`
 	actual := o.String()
@@ -3992,8 +4199,8 @@ func TestPrinterPrintStaticVar(t *testing.T) {
 func TestPrinterPrintStatic(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtStatic{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtStatic{
 		Vars: []ast.Vertex{
 			&ast.StmtStaticVar{
 				Var: &ast.ExprVariable{
@@ -4006,9 +4213,10 @@ func TestPrinterPrintStatic(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `static $a,$b;`
+	expected := `static$a,$b;`
 	actual := o.String()
 
 	if expected != actual {
@@ -4019,8 +4227,8 @@ func TestPrinterPrintStatic(t *testing.T) {
 func TestPrinterPrintStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtStmtList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtStmtList{
 		Stmts: []ast.Vertex{
 			&ast.StmtExpression{Expr: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -4029,7 +4237,8 @@ func TestPrinterPrintStmtList(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$b")},
 			}},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `{$a;$b;}`
 	actual := o.String()
@@ -4042,8 +4251,8 @@ func TestPrinterPrintStmtList(t *testing.T) {
 func TestPrinterPrintStmtListNested(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtStmtList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtStmtList{
 		Stmts: []ast.Vertex{
 			&ast.StmtExpression{Expr: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -4063,7 +4272,8 @@ func TestPrinterPrintStmtListNested(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `{$a;{$b;{$c;}}}`
 	actual := o.String()
@@ -4076,8 +4286,8 @@ func TestPrinterPrintStmtListNested(t *testing.T) {
 func TestPrinterPrintStmtSwitch(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtSwitch{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtSwitch{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
@@ -4099,9 +4309,10 @@ func TestPrinterPrintStmtSwitch(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `switch($var){case 'a':$a;case 'b':$b;}`
+	expected := `switch($var){case'a':$a;case'b':$b;}`
 	actual := o.String()
 
 	if expected != actual {
@@ -4112,14 +4323,15 @@ func TestPrinterPrintStmtSwitch(t *testing.T) {
 func TestPrinterPrintStmtThrow(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtThrow{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtThrow{
 		Expr: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$var")},
 		},
-	})
+	}
+	n.Accept(p)
 
-	expected := `throw $var;`
+	expected := `throw$var;`
 	actual := o.String()
 
 	if expected != actual {
@@ -4130,8 +4342,8 @@ func TestPrinterPrintStmtThrow(t *testing.T) {
 func TestPrinterPrintStmtTraitAdaptationList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitAdaptationList{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTraitAdaptationList{
 		Adaptations: []ast.Vertex{
 			&ast.StmtTraitUseAlias{
 				Ref: &ast.StmtTraitMethodRef{
@@ -4141,7 +4353,8 @@ func TestPrinterPrintStmtTraitAdaptationList(t *testing.T) {
 				Alias: &ast.Identifier{Value: []byte("b")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `{Foo::a as b;}`
 	actual := o.String()
@@ -4154,10 +4367,11 @@ func TestPrinterPrintStmtTraitAdaptationList(t *testing.T) {
 func TestPrinterPrintStmtTraitMethodRef(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitMethodRef{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTraitMethodRef{
 		Method: &ast.Identifier{Value: []byte("a")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `a`
 	actual := o.String()
@@ -4170,11 +4384,12 @@ func TestPrinterPrintStmtTraitMethodRef(t *testing.T) {
 func TestPrinterPrintStmtTraitMethodRefFull(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitMethodRef{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTraitMethodRef{
 		Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 		Method: &ast.Identifier{Value: []byte("a")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `Foo::a`
 	actual := o.String()
@@ -4187,15 +4402,16 @@ func TestPrinterPrintStmtTraitMethodRefFull(t *testing.T) {
 func TestPrinterPrintStmtTraitUseAlias(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitUseAlias{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTraitUseAlias{
 		Ref: &ast.StmtTraitMethodRef{
 			Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 			Method: &ast.Identifier{Value: []byte("a")},
 		},
 		Modifier: &ast.Identifier{Value: []byte("public")},
 		Alias:    &ast.Identifier{Value: []byte("b")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `Foo::a as public b;`
 	actual := o.String()
@@ -4208,8 +4424,8 @@ func TestPrinterPrintStmtTraitUseAlias(t *testing.T) {
 func TestPrinterPrintStmtTraitUsePrecedence(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitUsePrecedence{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTraitUsePrecedence{
 		Ref: &ast.StmtTraitMethodRef{
 			Trait:  &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 			Method: &ast.Identifier{Value: []byte("a")},
@@ -4218,7 +4434,8 @@ func TestPrinterPrintStmtTraitUsePrecedence(t *testing.T) {
 			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
 			&ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `Foo::a insteadof Bar,Baz;`
 	actual := o.String()
@@ -4231,14 +4448,15 @@ func TestPrinterPrintStmtTraitUsePrecedence(t *testing.T) {
 func TestPrinterPrintStmtTraitUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitUse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &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: &ast.StmtNop{},
-	})
+		Adaptations: &ast.StmtNop{},
+	}
+	n.Accept(p)
 
 	expected := `use Foo,Bar;`
 	actual := o.String()
@@ -4251,13 +4469,13 @@ func TestPrinterPrintStmtTraitUse(t *testing.T) {
 func TestPrinterPrintStmtTraitAdaptations(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTraitUse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &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: &ast.StmtTraitAdaptationList{
+		Adaptations: &ast.StmtTraitAdaptationList{
 			Adaptations: []ast.Vertex{
 				&ast.StmtTraitUseAlias{
 					Ref: &ast.StmtTraitMethodRef{
@@ -4268,7 +4486,8 @@ func TestPrinterPrintStmtTraitAdaptations(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `use Foo,Bar{Foo::a as b;}`
 	actual := o.String()
@@ -4281,8 +4500,8 @@ func TestPrinterPrintStmtTraitAdaptations(t *testing.T) {
 func TestPrinterPrintTrait(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTrait{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTrait{
 		TraitName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 		Stmts: []ast.Vertex{
 			&ast.StmtClassMethod{
@@ -4298,7 +4517,8 @@ func TestPrinterPrintTrait(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `trait Foo{public function foo(){$a;}}`
 	actual := o.String()
@@ -4311,8 +4531,8 @@ func TestPrinterPrintTrait(t *testing.T) {
 func TestPrinterPrintStmtTry(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtTry{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtTry{
 		Stmts: []ast.Vertex{
 			&ast.StmtExpression{Expr: &ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -4339,7 +4559,8 @@ func TestPrinterPrintStmtTry(t *testing.T) {
 				&ast.StmtNop{},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `try{$a;}catch(Exception|\RuntimeException$e){$b;}finally{;}`
 	actual := o.String()
@@ -4352,8 +4573,8 @@ func TestPrinterPrintStmtTry(t *testing.T) {
 func TestPrinterPrintStmtUnset(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtUnset{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtUnset{
 		Vars: []ast.Vertex{
 			&ast.ExprVariable{
 				VarName: &ast.Identifier{Value: []byte("$a")},
@@ -4362,7 +4583,8 @@ func TestPrinterPrintStmtUnset(t *testing.T) {
 				VarName: &ast.Identifier{Value: []byte("$b")},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `unset($a,$b);`
 	actual := o.String()
@@ -4375,8 +4597,8 @@ func TestPrinterPrintStmtUnset(t *testing.T) {
 func TestPrinterPrintUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtUse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtUse{
 		Type: &ast.Identifier{Value: []byte("function")},
 		UseDeclarations: []ast.Vertex{
 			&ast.StmtUseDeclaration{
@@ -4387,7 +4609,8 @@ func TestPrinterPrintUse(t *testing.T) {
 				Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `use function Foo as Bar,Baz;`
 	actual := o.String()
@@ -4400,8 +4623,8 @@ func TestPrinterPrintUse(t *testing.T) {
 func TestPrinterPrintStmtGroupUse(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtGroupUse{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtGroupUse{
 		Type:   &ast.Identifier{Value: []byte("function")},
 		Prefix: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 		UseDeclarations: []ast.Vertex{
@@ -4413,7 +4636,8 @@ func TestPrinterPrintStmtGroupUse(t *testing.T) {
 				Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `use function Foo\{Foo as Bar,Baz};`
 	actual := o.String()
@@ -4426,12 +4650,13 @@ func TestPrinterPrintStmtGroupUse(t *testing.T) {
 func TestPrinterPrintUseDeclaration(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtUseDeclaration{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtUseDeclaration{
 		Type:  &ast.Identifier{Value: []byte("function")},
 		Use:   &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
 		Alias: &ast.Identifier{Value: []byte("Bar")},
-	})
+	}
+	n.Accept(p)
 
 	expected := `function Foo as Bar`
 	actual := o.String()
@@ -4444,8 +4669,8 @@ func TestPrinterPrintUseDeclaration(t *testing.T) {
 func TestPrinterPrintWhileStmtList(t *testing.T) {
 	o := bytes.NewBufferString("")
 
-	p := printer.NewPrinter(o)
-	p.Print(&ast.StmtWhile{
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n := &ast.StmtWhile{
 		Cond: &ast.ExprVariable{
 			VarName: &ast.Identifier{Value: []byte("$a")},
 		},
@@ -4456,7 +4681,8 @@ func TestPrinterPrintWhileStmtList(t *testing.T) {
 				}},
 			},
 		},
-	})
+	}
+	n.Accept(p)
 
 	expected := `while($a){$a;}`
 	actual := o.String()
diff --git a/pkg/printer/printer.go b/pkg/printer/printer.go
deleted file mode 100644
index 026708e..0000000
--- a/pkg/printer/printer.go
+++ /dev/null
@@ -1,2838 +0,0 @@
-package printer
-
-import (
-	"bytes"
-	"io"
-	"strings"
-
-	"github.com/z7zmey/php-parser/pkg/ast"
-	"github.com/z7zmey/php-parser/pkg/token"
-)
-
-type printerState int
-
-const (
-	PhpState printerState = iota
-	HtmlState
-)
-
-type Printer struct {
-	w         io.Writer
-	s         printerState
-	bufStart  string
-	lastWrite []byte
-}
-
-// 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) write(b []byte) {
-	p.lastWrite = b
-	p.w.Write(b)
-}
-
-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() {
-			p.bufStart = "<?php "
-		}
-		p.SetState(PhpState)
-	}
-
-	p.printNode(n)
-}
-
-func (p *Printer) joinPrint(glue string, nn []ast.Vertex) {
-	for k, n := range nn {
-		if k > 0 {
-			p.write([]byte(glue))
-		}
-
-		p.Print(n)
-	}
-}
-
-func (p *Printer) joinPrintRefactored(glue string, nn []ast.Vertex) {
-	for k, n := range nn {
-		if k > 0 {
-			p.bufStart = glue
-		}
-
-		p.Print(n)
-	}
-}
-
-func (p *Printer) printSeparatedList(nodeList []ast.Vertex, separatorList []*token.Token, def string) {
-	var separators []*token.Token
-
-	if cap(separatorList) >= len(nodeList) {
-		separators = separatorList[:len(nodeList)]
-	} else {
-		separators = make([]*token.Token, len(nodeList))
-		copy(separators, separatorList)
-	}
-
-	for k, n := range nodeList {
-		p.Print(n)
-		if k < len(nodeList)-1 {
-			p.printToken(separators[k], def)
-		} else {
-			p.printToken(separators[k], "")
-		}
-	}
-}
-
-func (p *Printer) printNodes(nn []ast.Vertex) {
-	for _, n := range nn {
-		p.Print(n)
-	}
-}
-
-func (p *Printer) printFreeFloatingOrDefault(n ast.Vertex, pos token.Position, def string) {
-	if n == nil {
-		return
-	}
-
-	if len(n.GetNode().Tokens[pos]) == 0 {
-		p.write([]byte(def))
-		return
-	}
-
-	for _, m := range n.GetNode().Tokens[pos] {
-		p.write(m.Value)
-	}
-}
-
-func (p *Printer) printToken(t *token.Token, def string) {
-	if t != nil {
-		p.write(t.Skipped)
-		p.write(t.Value)
-		p.bufStart = ""
-		return
-	}
-
-	if def != "" {
-		p.write([]byte(p.bufStart))
-		p.bufStart = ""
-
-		p.write([]byte(def))
-		return
-	}
-}
-
-func (p *Printer) printFreeFloating(n ast.Vertex, pos token.Position) {
-	if n == nil {
-		return
-	}
-
-	for _, m := range n.GetNode().Tokens[pos] {
-		p.write(m.Value)
-	}
-}
-
-func (p *Printer) printNode(n ast.Vertex) {
-	switch n := 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.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.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.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.StmtUse:
-		p.printStmtUse(n)
-	case *ast.StmtGroupUse:
-		p.printStmtGroupUse(n)
-	case *ast.StmtUseDeclaration:
-		p.printStmtUseDeclaration(n)
-	case *ast.StmtWhile:
-		p.printStmtWhile(n)
-	case *ast.ParserBrackets:
-		p.printParserBrackets(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.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(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.Print(nn.Var)
-
-	if nn.DefaultValue != nil {
-		p.write([]byte("="))
-		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)
-
-	p.write([]byte("?"))
-	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.AmpersandTkn != nil {
-		p.write([]byte("&"))
-	}
-	p.printFreeFloating(nn, token.Ampersand)
-
-	if nn.VariadicTkn != nil {
-		p.write([]byte("..."))
-	}
-
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-// name
-
-func (p *Printer) printNameNamePart(n *ast.NameNamePart) {
-	p.printToken(n.StringTkn, string(n.Value))
-}
-
-func (p *Printer) printNameName(n *ast.NameName) {
-	p.printFreeFloating(n, token.Start)
-
-	p.joinPrintRefactored("\\", n.Parts)
-}
-
-func (p *Printer) printNameFullyQualified(n *ast.NameFullyQualified) {
-	p.printFreeFloating(n, token.Start)
-	p.printToken(n.NsSeparatorTkn, "\\")
-
-	p.joinPrintRefactored("\\", n.Parts)
-}
-
-func (p *Printer) printNameRelative(n *ast.NameRelative) {
-	p.printFreeFloating(n, token.Start)
-	p.printToken(n.NsTkn, "namespace")
-	p.printToken(n.NsSeparatorTkn, "\\")
-
-	p.joinPrintRefactored("\\", n.Parts)
-}
-
-// scalar
-
-func (p *Printer) printScalarLNumber(n ast.Vertex) {
-	nn := n.(*ast.ScalarLnumber)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(nn.Value)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printScalarDNumber(n ast.Vertex) {
-	nn := n.(*ast.ScalarDnumber)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(nn.Value)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printScalarString(n ast.Vertex) {
-	nn := n.(*ast.ScalarString)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(nn.Value)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printScalarEncapsedStringPart(n ast.Vertex) {
-	nn := n.(*ast.ScalarEncapsedStringPart)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(nn.Value)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printScalarEncapsed(n ast.Vertex) {
-	nn := n.(*ast.ScalarEncapsed)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write([]byte("\""))
-	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)
-		}
-	}
-	p.write([]byte("\""))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printScalarHeredoc(n ast.Vertex) {
-	nn := n.(*ast.ScalarHeredoc)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(nn.OpenHeredocTkn.Value)
-
-	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)
-		}
-	}
-
-	p.write([]byte(strings.Trim(string(nn.OpenHeredocTkn.Value), "<\"'\n")))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printScalarMagicConstant(n ast.Vertex) {
-	nn := n.(*ast.ScalarMagicConstant)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	p.write(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)
-	p.write([]byte("="))
-	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)
-	p.write([]byte("="))
-	p.printFreeFloating(nn, token.Equal)
-	p.write([]byte("&"))
-	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)
-	p.write([]byte("&"))
-	p.write([]byte("="))
-	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)
-	p.write([]byte("|="))
-	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)
-	p.write([]byte("^="))
-	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)
-	p.write([]byte("??="))
-	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)
-	p.write([]byte(".="))
-	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)
-	p.write([]byte("/="))
-	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)
-	p.write([]byte("-="))
-	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)
-	p.write([]byte("%="))
-	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)
-	p.write([]byte("*="))
-	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)
-	p.write([]byte("+="))
-	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)
-	p.write([]byte("**="))
-	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)
-	p.write([]byte("<<="))
-	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)
-	p.write([]byte(">>="))
-	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)
-	p.write([]byte("&"))
-	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)
-	p.write([]byte("|"))
-	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)
-	p.write([]byte("^"))
-	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)
-	p.write([]byte("&&"))
-	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)
-	p.write([]byte("||"))
-	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)
-	p.write([]byte("??"))
-	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)
-	p.write([]byte("."))
-	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)
-	p.write([]byte("/"))
-	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)
-	p.write([]byte("=="))
-	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)
-	p.write([]byte(">="))
-	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)
-	p.write([]byte(">"))
-	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)
-	p.write([]byte("==="))
-	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() {
-		p.write([]byte(" "))
-	}
-	p.write([]byte("and"))
-	if nn.Right.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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() {
-		p.write([]byte(" "))
-	}
-	p.write([]byte("or"))
-	if nn.Right.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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() {
-		p.write([]byte(" "))
-	}
-	p.write([]byte("xor"))
-	if nn.Right.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-	p.write([]byte("-"))
-	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)
-	p.write([]byte("%"))
-	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)
-	p.write([]byte("*"))
-	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() {
-		p.write([]byte("!="))
-	}
-	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)
-	p.write([]byte("!=="))
-	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)
-	p.write([]byte("+"))
-	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)
-	p.write([]byte("**"))
-	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)
-	p.write([]byte("<<"))
-	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)
-	p.write([]byte(">>"))
-	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)
-	p.write([]byte("<="))
-	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)
-	p.write([]byte("<"))
-	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)
-	p.write([]byte("<=>"))
-	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() {
-		p.write([]byte("(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() {
-		p.write([]byte("(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() {
-		p.write([]byte("(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() {
-		p.write([]byte("(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() {
-		p.write([]byte("(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() {
-		p.write([]byte("(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() {
-		p.write([]byte("(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() {
-		p.write([]byte("["))
-	}
-	p.Print(nn.Dim)
-	p.printFreeFloating(nn, token.Expr)
-	if nn.GetNode().Tokens.IsEmpty() {
-		p.write([]byte("]"))
-	}
-	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() {
-		p.write([]byte("["))
-	}
-	p.Print(nn.Dim)
-	p.printFreeFloating(nn, token.Expr)
-	if nn.GetNode().Tokens.IsEmpty() {
-		p.write([]byte("]"))
-	}
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprArrayItem(n ast.Vertex) {
-	nn := n.(*ast.ExprArrayItem)
-	p.printFreeFloating(nn, token.Start)
-
-	if nn.EllipsisTkn != nil {
-		p.write([]byte("..."))
-	}
-
-	if nn.Key != nil {
-		p.Print(nn.Key)
-		p.printFreeFloating(nn, token.Expr)
-		p.write([]byte("=>"))
-	}
-
-	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)
-	p.write([]byte("array"))
-	p.printFreeFloating(nn, token.Array)
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Items)
-	p.printFreeFloating(nn, token.ArrayPairList)
-	p.write([]byte(")"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprArrowFunction(n ast.Vertex) {
-	nn := n.(*ast.ExprArrowFunction)
-	p.printFreeFloating(nn, token.Start)
-
-	if nn.StaticTkn != nil {
-		p.write([]byte("static"))
-	}
-	p.printFreeFloating(nn, token.Static)
-	if nn.StaticTkn != nil && n.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-
-	p.write([]byte("fn"))
-	p.printFreeFloating(nn, token.Function)
-
-	if nn.AmpersandTkn != nil {
-		p.write([]byte("&"))
-	}
-	p.printFreeFloating(nn, token.Ampersand)
-
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, token.ParameterList)
-	p.write([]byte(")"))
-	p.printFreeFloating(nn, token.Params)
-
-	if nn.ReturnType != nil {
-		p.bufStart = ":"
-		p.Print(nn.ReturnType)
-	}
-	p.printFreeFloating(nn, token.ReturnType)
-
-	p.write([]byte("=>"))
-
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprBitwiseNot(n ast.Vertex) {
-	nn := n.(*ast.ExprBitwiseNot)
-	p.printFreeFloating(nn, token.Start)
-	p.write([]byte("~"))
-	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)
-	p.write([]byte("!"))
-	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)
-	p.write([]byte("::"))
-	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)
-	p.write([]byte("clone"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-	p.write([]byte("use"))
-	p.printFreeFloating(nn, token.Use)
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Uses)
-	p.printFreeFloating(nn, token.LexicalVarList)
-	p.write([]byte(")"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprClosure(n ast.Vertex) {
-	nn := n.(*ast.ExprClosure)
-	p.printFreeFloating(nn, token.Start)
-
-	if nn.StaticTkn != nil {
-		p.write([]byte("static"))
-	}
-	p.printFreeFloating(nn, token.Static)
-	if nn.StaticTkn != nil && n.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-
-	p.write([]byte("function"))
-	p.printFreeFloating(nn, token.Function)
-
-	if nn.AmpersandTkn != nil {
-		p.write([]byte("&"))
-	}
-	p.printFreeFloating(nn, token.Ampersand)
-
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, token.ParameterList)
-	p.write([]byte(")"))
-	p.printFreeFloating(nn, token.Params)
-
-	if nn.ClosureUse != nil {
-		p.Print(nn.ClosureUse)
-	}
-	p.printFreeFloating(nn, token.LexicalVars)
-
-	if nn.ReturnType != nil {
-		p.bufStart = ":"
-		p.Print(nn.ReturnType)
-	}
-	p.printFreeFloating(nn, token.ReturnType)
-
-	p.write([]byte("{"))
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, token.Stmts)
-	p.write([]byte("}"))
-
-	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)
-	p.write([]byte("empty"))
-
-	if _, ok := nn.Expr.(*ast.ParserBrackets); !ok {
-		p.write([]byte("("))
-	}
-
-	p.Print(nn.Expr)
-
-	if _, ok := nn.Expr.(*ast.ParserBrackets); !ok {
-		p.write([]byte(")"))
-	}
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprErrorSuppress(n ast.Vertex) {
-	nn := n.(*ast.ExprErrorSuppress)
-	p.printFreeFloating(nn, token.Start)
-	p.write([]byte("@"))
-	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)
-
-	p.write([]byte("eval"))
-
-	if _, ok := nn.Expr.(*ast.ParserBrackets); !ok {
-		p.write([]byte("("))
-	}
-
-	p.Print(nn.Expr)
-
-	if _, ok := nn.Expr.(*ast.ParserBrackets); !ok {
-		p.write([]byte(")"))
-	}
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprExit(n ast.Vertex) {
-	nn := n.(*ast.ExprExit)
-	p.printFreeFloating(nn, token.Start)
-
-	if nn.DieTkn != nil {
-		p.write(nn.DieTkn.Value)
-	} else {
-		p.write([]byte("exit"))
-	}
-
-	if nn.Expr != nil && nn.Expr.GetNode().Tokens.IsEmpty() && nn.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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.printToken(nn.OpenParenthesisTkn, "(")
-	p.joinPrint(",", nn.Arguments)
-	p.printToken(nn.CloseParenthesisTkn, ")")
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprInclude(n ast.Vertex) {
-	nn := n.(*ast.ExprInclude)
-	p.printFreeFloating(nn, token.Start)
-	p.write([]byte("include"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-	p.write([]byte("include_once"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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() {
-		p.write([]byte(" "))
-	}
-
-	p.write([]byte("instanceof"))
-
-	p.bufStart = " "
-	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)
-
-	p.write([]byte("isset"))
-	p.printFreeFloating(nn, token.Isset)
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Vars)
-	p.printFreeFloating(nn, token.VarList)
-	p.write([]byte(")"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprList(n ast.Vertex) {
-	nn := n.(*ast.ExprList)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("list"))
-	p.printFreeFloating(nn, token.List)
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Items)
-	p.printFreeFloating(nn, token.ArrayPairList)
-	p.write([]byte(")"))
-
-	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)
-	p.write([]byte("->"))
-	p.Print(nn.Method)
-
-	p.printToken(nn.OpenParenthesisTkn, "(")
-	p.joinPrint(",", nn.Arguments)
-	p.printToken(nn.CloseParenthesisTkn, ")")
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprNew(n ast.Vertex) {
-	nn := n.(*ast.ExprNew)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("new"))
-	p.bufStart = " "
-	p.Print(nn.Class)
-
-	if nn.Arguments != nil {
-		p.printToken(nn.OpenParenthesisTkn, "(")
-		p.joinPrint(",", nn.Arguments)
-		p.printToken(nn.CloseParenthesisTkn, ")")
-	}
-
-	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)
-	p.write([]byte("--"))
-
-	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)
-	p.write([]byte("++"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprPreDec(n ast.Vertex) {
-	nn := n.(*ast.ExprPreDec)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("--"))
-	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)
-
-	p.write([]byte("++"))
-	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)
-
-	p.write([]byte("print"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-	p.write([]byte("->"))
-	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)
-
-	p.write([]byte("&"))
-	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)
-
-	p.write([]byte("require"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-
-	p.write([]byte("require_once"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-
-	p.write([]byte("`"))
-	p.joinPrint("", nn.Parts)
-	p.write([]byte("`"))
-
-	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)
-	p.write([]byte("::"))
-	p.Print(nn.Call)
-
-	p.printToken(nn.OpenParenthesisTkn, "(")
-	p.joinPrint(",", nn.Arguments)
-	p.printToken(nn.CloseParenthesisTkn, ")")
-
-	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)
-	p.write([]byte("::"))
-	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)
-	p.write([]byte("?"))
-
-	if nn.IfTrue != nil {
-		p.Print(nn.IfTrue)
-	}
-	p.printFreeFloating(nn, token.True)
-
-	p.write([]byte(":"))
-	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)
-
-	p.write([]byte("-"))
-	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)
-
-	p.write([]byte("+"))
-	p.Print(nn.Expr)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printExprVariable(n ast.Vertex) {
-	nn := n.(*ast.ExprVariable)
-	p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	if _, ok := nn.VarName.(*ast.Identifier); !ok {
-		p.write([]byte("$"))
-	}
-
-	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)
-
-	p.write([]byte("yield from"))
-	if nn.Expr.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	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)
-
-	p.write([]byte("yield"))
-
-	if nn.Key != nil {
-		if nn.Key.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.Print(nn.Key)
-		p.printFreeFloating(nn, token.Expr)
-		p.write([]byte("=>"))
-	} else {
-		if nn.Value.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-	}
-
-	p.Print(nn.Value)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-// smtm
-
-func (p *Printer) printStmtBreak(n *ast.StmtBreak) {
-	p.printToken(n.BreakTkn, "break")
-
-	if n.Expr != nil {
-		p.bufStart = " "
-	}
-
-	p.Print(n.Expr)
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtCase(n *ast.StmtCase) {
-	p.printToken(n.CaseTkn, "case")
-	p.bufStart = " "
-	p.Print(n.Cond)
-	p.printToken(n.CaseSeparatorTkn, ":")
-	p.printNodes(n.Stmts)
-}
-
-func (p *Printer) printStmtCatch(n *ast.StmtCatch) {
-	p.printToken(n.CatchTkn, "catch")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.printSeparatedList(n.Types, n.SeparatorTkns, "|")
-	p.Print(n.Var)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.OpenCurlyBracketTkn, "{")
-	p.printNodes(n.Stmts)
-	p.printToken(n.CloseCurlyBracketTkn, "}")
-}
-
-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() {
-				p.write([]byte(" "))
-			}
-			p.Print(m)
-		}
-
-		if nn.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-	}
-	p.printFreeFloating(nn, token.ModifierList)
-	p.write([]byte("function"))
-	p.printFreeFloating(nn, token.Function)
-
-	if nn.AmpersandTkn != nil {
-		if nn.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.write([]byte("&"))
-		p.printFreeFloating(nn, token.Ampersand)
-	} else {
-		if nn.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-	}
-
-	p.Print(nn.MethodName)
-	p.printFreeFloating(nn, token.Name)
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, token.ParameterList)
-	p.write([]byte(")"))
-	p.printFreeFloating(nn, token.Params)
-
-	if nn.ReturnType != nil {
-		p.bufStart = ":"
-		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.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
-	p.bufStart = ""
-
-	if nn.Modifiers != nil {
-		for k, m := range nn.Modifiers {
-			if k > 0 && m.GetNode().Tokens.IsEmpty() {
-				p.write([]byte(" "))
-			}
-			p.Print(m)
-		}
-
-		if nn.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-	}
-	p.printFreeFloating(nn, token.ModifierList)
-	p.write([]byte("class"))
-
-	if nn.ClassName != nil {
-		p.bufStart = " "
-		p.Print(nn.ClassName)
-	}
-
-	if nn.Arguments != nil {
-		p.printToken(nn.OpenParenthesisTkn, "(")
-		p.joinPrint(",", nn.Arguments)
-		p.printToken(nn.CloseParenthesisTkn, ")")
-	}
-
-	if nn.Extends != nil {
-		p.printFreeFloating(nn.Extends, token.Start)
-		if nn.Extends.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.write([]byte("extends"))
-		p.bufStart = " "
-		p.Print(nn.Extends.(*ast.StmtClassExtends).ClassName)
-	}
-
-	if nn.Implements != nil {
-		p.printFreeFloating(nn.Implements, token.Start)
-		if nn.Implements.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.write([]byte("implements"))
-		p.bufStart = " "
-		p.joinPrintRefactored(",", nn.Implements.(*ast.StmtClassImplements).InterfaceNames)
-
-	}
-
-	p.printFreeFloating(nn, token.Name)
-	p.write([]byte("{"))
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, token.Stmts)
-	p.write([]byte("}"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtClassConstList(n *ast.StmtClassConstList) {
-	p.joinPrintRefactored(" ", n.Modifiers)
-	p.bufStart = " "
-	p.printToken(n.ConstTkn, "const")
-	p.bufStart = " "
-	p.joinPrintRefactored(",", n.Consts)
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtConstList(n *ast.StmtConstList) {
-	p.printToken(n.ConstTkn, "const")
-	p.bufStart = " "
-	p.printSeparatedList(n.Consts, n.SeparatorTkns, ",")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtConstant(n *ast.StmtConstant) {
-	p.Print(n.Name)
-	p.printToken(n.EqualTkn, "=")
-	p.Print(n.Expr)
-}
-
-func (p *Printer) printStmtContinue(n *ast.StmtContinue) {
-	p.printToken(n.ContinueTkn, "continue")
-
-	if n.Expr != nil {
-		p.bufStart = " "
-	}
-
-	p.Print(n.Expr)
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtDeclare(n *ast.StmtDeclare) {
-	if n.Alt {
-		p.printStmtAltDeclare(n)
-		return
-	}
-	p.printToken(n.DeclareTkn, "declare")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.printSeparatedList(n.Consts, n.SeparatorTkns, ",")
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.Print(n.Stmt)
-}
-
-func (p *Printer) printStmtAltDeclare(n *ast.StmtDeclare) {
-	p.printToken(n.DeclareTkn, "declare")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.printSeparatedList(n.Consts, n.SeparatorTkns, ",")
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-
-	p.printToken(n.EndDeclareTkn, "enddeclare")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtDefault(n *ast.StmtDefault) {
-	p.printToken(n.DefaultTkn, "default")
-	p.printToken(n.CaseSeparatorTkn, ":")
-	p.printNodes(n.Stmts)
-}
-
-func (p *Printer) printStmtDo(n *ast.StmtDo) {
-	p.printToken(n.DoTkn, "do")
-	p.bufStart = " "
-
-	p.Print(n.Stmt)
-
-	p.printToken(n.WhileTkn, "while")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtEcho(n *ast.StmtEcho) {
-	p.printToken(n.EchoTkn, "echo")
-	p.bufStart = " "
-	p.printSeparatedList(n.Exprs, n.SeparatorTkns, ",")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtElseif(n *ast.StmtElseIf) {
-	if n.Alt {
-		p.printStmtAltElseIf(n)
-		return
-	}
-
-	p.printToken(n.ElseIfTkn, "elseif")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-
-	p.Print(n.Stmt)
-}
-
-func (p *Printer) printStmtAltElseIf(n *ast.StmtElseIf) {
-	p.printToken(n.ElseIfTkn, "elseif")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-}
-
-func (p *Printer) printStmtElse(n *ast.StmtElse) {
-	if n.Alt {
-		p.printStmtAltElse(n)
-		return
-	}
-
-	p.printToken(n.ElseTkn, "else")
-	p.bufStart = " "
-	p.Print(n.Stmt)
-}
-
-func (p *Printer) printStmtAltElse(n *ast.StmtElse) {
-	p.printToken(n.ElseTkn, "else")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-}
-
-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() {
-		p.write([]byte(";"))
-	}
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtFinally(n *ast.StmtFinally) {
-	p.printToken(n.FinallyTkn, "finally")
-	p.printToken(n.OpenCurlyBracketTkn, "{")
-	p.printNodes(n.Stmts)
-	p.printToken(n.CloseCurlyBracketTkn, "}")
-}
-
-func (p *Printer) printStmtFor(n *ast.StmtFor) {
-	if n.Alt {
-		p.printStmtAltFor(n)
-		return
-	}
-
-	p.printToken(n.ForTkn, "for")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.joinPrint(",", n.Init)
-	p.printToken(n.InitSemiColonTkn, ";")
-	p.joinPrint(",", n.Cond)
-	p.printToken(n.CondSemiColonTkn, ";")
-	p.joinPrint(",", n.Loop)
-	p.printToken(n.CloseParenthesisTkn, ")")
-
-	p.Print(n.Stmt)
-}
-
-func (p *Printer) printStmtAltFor(n *ast.StmtFor) {
-	p.printToken(n.ForTkn, "for")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.joinPrint(",", n.Init)
-	p.printToken(n.InitSemiColonTkn, ";")
-	p.joinPrint(",", n.Cond)
-	p.printToken(n.CondSemiColonTkn, ";")
-	p.joinPrint(",", n.Loop)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-
-	p.printToken(n.EndForTkn, "endfor")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtForeach(n *ast.StmtForeach) {
-	if n.Alt {
-		p.printStmtAltForeach(n)
-		return
-	}
-
-	p.printToken(n.ForeachTkn, "foreach")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Expr)
-	p.bufStart = " "
-	p.printToken(n.AsTkn, "as")
-	p.bufStart = " "
-	if n.Key != nil {
-		p.Print(n.Key)
-		p.printToken(n.DoubleArrowTkn, "=>")
-	}
-	p.Print(n.Var)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.Print(n.Stmt)
-}
-
-func (p *Printer) printStmtAltForeach(n *ast.StmtForeach) {
-	p.printToken(n.ForeachTkn, "foreach")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Expr)
-	p.bufStart = " "
-	p.printToken(n.AsTkn, "as")
-	p.bufStart = " "
-	if n.Key != nil {
-		p.Print(n.Key)
-		p.printToken(n.DoubleArrowTkn, "=>")
-	}
-	p.Print(n.Var)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-
-	p.printToken(n.EndForeachTkn, "endforeach")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtFunction(n ast.Vertex) {
-	nn := n.(*ast.StmtFunction)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("function"))
-	p.printFreeFloating(nn, token.Function)
-
-	if nn.AmpersandTkn != nil {
-		if nn.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.write([]byte("&"))
-	} else {
-		if nn.FunctionName.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-	}
-
-	p.Print(nn.FunctionName)
-	p.printFreeFloating(nn, token.Name)
-
-	p.write([]byte("("))
-	p.joinPrint(",", nn.Params)
-	p.printFreeFloating(nn, token.ParamList)
-	p.write([]byte(")"))
-	p.printFreeFloating(nn, token.Params)
-
-	if nn.ReturnType != nil {
-		p.bufStart = ":"
-		p.Print(nn.ReturnType)
-	}
-	p.printFreeFloating(nn, token.ReturnType)
-
-	p.write([]byte("{"))
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, token.Stmts)
-	p.write([]byte("}"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtGlobal(n *ast.StmtGlobal) {
-	p.printToken(n.GlobalTkn, "global")
-	p.bufStart = " "
-	p.printSeparatedList(n.Vars, n.SeparatorTkns, ",")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtGoto(n *ast.StmtGoto) {
-	p.printToken(n.GotoTkn, "goto")
-	p.bufStart = " "
-	p.Print(n.Label)
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtHaltCompiler(n *ast.StmtHaltCompiler) {
-	p.printToken(n.HaltCompilerTkn, "__halt_compiler")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtIf(n *ast.StmtIf) {
-	if n.Alt {
-		p.printStmtAltIf(n)
-		return
-	}
-
-	p.printToken(n.IfTkn, "if")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-
-	p.Print(n.Stmt)
-	p.printNodes(n.ElseIf)
-	p.Print(n.Else)
-}
-
-func (p *Printer) printStmtAltIf(n *ast.StmtIf) {
-	p.printToken(n.IfTkn, "if")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-
-	p.printNodes(n.ElseIf)
-	p.Print(n.Else)
-
-	p.printToken(n.EndIfTkn, "endif")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtInlineHTML(n *ast.StmtInlineHtml) {
-	if p.s == PhpState && !bytes.Contains(p.lastWrite, []byte("?>")) {
-		p.write([]byte("?>"))
-	}
-	p.SetState(HtmlState)
-
-	p.printToken(n.InlineHtmlTkn, string(n.Value))
-}
-
-func (p *Printer) printStmtInterface(n ast.Vertex) {
-	nn := n.(*ast.StmtInterface)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("interface"))
-
-	if nn.InterfaceName.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-
-	p.Print(nn.InterfaceName)
-
-	if nn.Extends != nil {
-		p.printFreeFloating(nn.Extends, token.Start)
-		if nn.Extends.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.write([]byte("extends"))
-		p.bufStart = " "
-		p.joinPrintRefactored(",", nn.Extends.(*ast.StmtInterfaceExtends).InterfaceNames)
-	}
-
-	p.printFreeFloating(nn, token.Name)
-	p.write([]byte("{"))
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, token.Stmts)
-	p.write([]byte("}"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtLabel(n *ast.StmtLabel) {
-	p.Print(n.LabelName)
-	p.printToken(n.ColonTkn, ":")
-}
-
-func (p *Printer) printStmtNamespace(n *ast.StmtNamespace) {
-	p.printToken(n.NsTkn, "namespace")
-
-	if n.Name != nil {
-		p.bufStart = " "
-		p.Print(n.Name)
-	}
-
-	if n.Stmts != nil {
-		p.printToken(n.OpenCurlyBracket, "{")
-		p.printNodes(n.Stmts)
-		p.printToken(n.CloseCurlyBracket, "}")
-		return
-	}
-
-	if n.OpenCurlyBracket != nil {
-		p.printToken(n.OpenCurlyBracket, "{")
-		p.printToken(n.CloseCurlyBracket, "}")
-		return
-	}
-
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtNop(n *ast.StmtNop) {
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-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() {
-			p.write([]byte(" "))
-		}
-		p.Print(m)
-	}
-
-	if nn.Type != nil {
-		p.bufStart = " "
-		p.Print(nn.Type)
-	}
-
-	if nn.Properties[0].GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-
-	p.joinPrint(",", nn.Properties)
-	p.printFreeFloating(n, token.PropertyList)
-
-	p.printFreeFloating(n, token.SemiColon)
-	if n.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(";"))
-	}
-
-	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)
-		p.write([]byte("="))
-		p.Print(nn.Expr)
-	}
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtReturn(n *ast.StmtReturn) {
-	p.printToken(n.ReturnTkn, "return")
-
-	if n.Expr != nil {
-		p.bufStart = " "
-	}
-	p.Print(n.Expr)
-
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtStaticVar(n *ast.StmtStaticVar) {
-	p.Print(n.Var)
-
-	if n.Expr != nil {
-		p.printToken(n.EqualTkn, "=")
-		p.Print(n.Expr)
-	}
-}
-
-func (p *Printer) printStmtStatic(n *ast.StmtStatic) {
-	p.printToken(n.StaticTkn, "static")
-	p.bufStart = " "
-	p.printSeparatedList(n.Vars, n.SeparatorTkns, ",")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtStmtList(n *ast.StmtStmtList) {
-	p.printToken(n.OpenCurlyBracket, "{")
-	p.printNodes(n.Stmts)
-	p.printToken(n.CloseCurlyBracket, "}")
-}
-
-func (p *Printer) printStmtSwitch(n *ast.StmtSwitch) {
-	if n.Alt {
-		p.printStmtAltSwitch(n)
-		return
-	}
-
-	p.printToken(n.SwitchTkn, "switch")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.OpenCurlyBracketTkn, "{")
-	p.printToken(n.CaseSeparatorTkn, "")
-	p.printNodes(n.CaseList)
-	p.printToken(n.CloseCurlyBracketTkn, "}")
-}
-
-func (p *Printer) printStmtAltSwitch(n *ast.StmtSwitch) {
-	p.printToken(n.SwitchTkn, "switch")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-	p.printToken(n.CaseSeparatorTkn, "")
-	p.printNodes(n.CaseList)
-	p.printToken(n.EndSwitchTkn, "endswitch")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtThrow(n *ast.StmtThrow) {
-	p.printToken(n.ThrowTkn, "throw")
-	p.bufStart = " "
-	p.Print(n.Expr)
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtTraitAdaptationList(n ast.Vertex) {
-	nn := n.(*ast.StmtTraitAdaptationList)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("{"))
-	p.printNodes(nn.Adaptations)
-	p.printFreeFloating(nn, token.AdaptationList)
-	p.write([]byte("}"))
-
-	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)
-		p.write([]byte("::"))
-	}
-
-	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() {
-		p.write([]byte(" "))
-	}
-	p.write([]byte("as"))
-
-	if nn.Modifier != nil {
-		if nn.Modifier.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.Print(nn.Modifier)
-	}
-
-	if nn.Alias != nil {
-		if nn.Alias.GetNode().Tokens.IsEmpty() {
-			p.write([]byte(" "))
-		}
-		p.Print(nn.Alias)
-	}
-	p.printFreeFloating(nn, token.Alias)
-
-	p.printFreeFloating(nn, token.SemiColon)
-	if n.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(";"))
-	}
-
-	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() {
-		p.write([]byte(" "))
-	}
-
-	p.write([]byte("insteadof"))
-	p.bufStart = " "
-	p.joinPrint(",", nn.Insteadof)
-	p.printFreeFloating(nn, token.NameList)
-
-	p.printFreeFloating(nn, token.SemiColon)
-	if n.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(";"))
-	}
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtTraitUse(n ast.Vertex) {
-	nn := n.(*ast.StmtTraitUse)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("use"))
-	p.bufStart = " "
-	p.joinPrintRefactored(",", nn.Traits)
-
-	p.Print(nn.Adaptations)
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtTrait(n ast.Vertex) {
-	nn := n.(*ast.StmtTrait)
-	p.printFreeFloating(nn, token.Start)
-
-	p.write([]byte("trait"))
-	if nn.TraitName.GetNode().Tokens.IsEmpty() {
-		p.write([]byte(" "))
-	}
-	p.Print(nn.TraitName)
-
-	p.printFreeFloating(nn, token.Name)
-	p.write([]byte("{"))
-	p.printNodes(nn.Stmts)
-	p.printFreeFloating(nn, token.Stmts)
-	p.write([]byte("}"))
-
-	p.printFreeFloating(nn, token.End)
-}
-
-func (p *Printer) printStmtTry(n *ast.StmtTry) {
-	p.printToken(n.TryTkn, "try")
-	p.printToken(n.OpenCurlyBracket, "{")
-	p.printNodes(n.Stmts)
-	p.printToken(n.CloseCurlyBracket, "}")
-
-	if n.Catches != nil {
-		p.printNodes(n.Catches)
-	}
-
-	if n.Finally != nil {
-		p.Print(n.Finally)
-	}
-}
-
-func (p *Printer) printStmtUnset(n *ast.StmtUnset) {
-	p.printToken(n.UnsetTkn, "unset")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.printSeparatedList(n.Vars, n.SeparatorTkns, ",")
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtUse(n *ast.StmtUse) {
-	p.printToken(n.UseTkn, "use")
-
-	if n.Type != nil {
-		p.bufStart = " "
-		p.Print(n.Type)
-	}
-
-	p.bufStart = " "
-	p.joinPrintRefactored(",", n.UseDeclarations)
-
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtGroupUse(n *ast.StmtGroupUse) {
-	p.printToken(n.UseTkn, "use")
-
-	p.bufStart = " "
-	p.Print(n.Type)
-
-	p.bufStart = " "
-	p.printToken(n.LeadingNsSeparatorTkn, "")
-
-	p.Print(n.Prefix)
-	p.printToken(n.NsSeparatorTkn, "\\")
-	p.printToken(n.OpenCurlyBracketTkn, "{")
-
-	p.joinPrintRefactored(",", n.UseDeclarations)
-
-	p.printToken(n.CloseCurlyBracketTkn, "}")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printStmtUseDeclaration(n *ast.StmtUseDeclaration) {
-	p.Print(n.Type)
-
-	if n.Type != nil {
-		p.bufStart = " "
-	}
-
-	p.printToken(n.NsSeparatorTkn, "")
-
-	p.Print(n.Use)
-
-	if n.Alias == nil {
-		return
-	}
-
-	p.bufStart = " "
-	p.printToken(n.AsTkn, "as")
-
-	p.bufStart = " "
-	p.Print(n.Alias)
-}
-
-func (p *Printer) printStmtWhile(n *ast.StmtWhile) {
-	if n.Alt {
-		p.printStmtAltWhile(n)
-		return
-	}
-
-	p.printToken(n.WhileTkn, "while")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-
-	p.Print(n.Stmt)
-}
-
-func (p *Printer) printStmtAltWhile(n *ast.StmtWhile) {
-	p.printToken(n.WhileTkn, "while")
-	p.printToken(n.OpenParenthesisTkn, "(")
-	p.Print(n.Cond)
-	p.printToken(n.CloseParenthesisTkn, ")")
-	p.printToken(n.ColonTkn, ":")
-
-	if stmtList, ok := n.Stmt.(*ast.StmtStmtList); ok {
-		p.printNodes(stmtList.Stmts)
-	} else {
-		p.Print(n.Stmt)
-	}
-
-	p.printToken(n.EndWhileTkn, "endwhile")
-	p.printToken(n.SemiColonTkn, ";")
-}
-
-func (p *Printer) printParserBrackets(n ast.Vertex) {
-	nn := n.(*ast.ParserBrackets)
-	p.printFreeFloating(nn, token.Start)
-
-	p.Print(nn.Child)
-
-	p.printFreeFloating(nn, token.End)
-}