diff --git a/cmd/php-parser/main.go b/cmd/php-parser/main.go
index 569dd30..33d03e0 100644
--- a/cmd/php-parser/main.go
+++ b/cmd/php-parser/main.go
@@ -13,8 +13,8 @@ import (
"github.com/pkg/profile"
"github.com/yookoala/realpath"
- "github.com/z7zmey/php-parser/pkg/parser"
"github.com/z7zmey/php-parser/pkg/ast/visitor"
+ "github.com/z7zmey/php-parser/pkg/parser"
)
var wg sync.WaitGroup
diff --git a/internal/php5/parser.go b/internal/php5/parser.go
index 060be97..d4ec16d 100644
--- a/internal/php5/parser.go
+++ b/internal/php5/parser.go
@@ -2,6 +2,7 @@ package php5
import (
"bytes"
+ "fmt"
"github.com/z7zmey/php-parser/internal/positionbuilder"
"github.com/z7zmey/php-parser/internal/scanner"
@@ -132,10 +133,25 @@ func (l *Parser) GetFreeFloatingToken(t *scanner.Token) []token.Token {
return []token.Token{}
}
- tokens := make([]token.Token, len(t.Tokens))
- copy(tokens, t.Tokens)
+ return []token.Token{
+ {
+ ID: token.ID(t.ID),
+ Value: t.Value,
+ },
+ }
+}
- return tokens
+func (l *Parser) addDollarToken(v ast.Vertex) {
+ if l.Lexer.GetWithFreeFloating() == false {
+ return
+ }
+
+ l.setFreeFloating(v, token.Dollar, []token.Token{
+ {
+ ID: token.ID('$'),
+ Value: []byte("$"),
+ },
+ })
}
func (l *Parser) splitSemiColonAndPhpCloseTag(htmlNode ast.Vertex, prevNode ast.Vertex) {
@@ -159,6 +175,8 @@ func (l *Parser) splitSemiColonAndPhpCloseTag(htmlNode ast.Vertex, prevNode ast.
}
vlen := len(semiColon[0].Value)
+ fmt.Printf("vlen: %q\n", string(semiColon[0].Value))
+
tlen := 2
if bytes.HasSuffix(semiColon[0].Value, []byte("?>\n")) {
tlen = 3
diff --git a/internal/php5/php5.go b/internal/php5/php5.go
index 0b7071c..b63ef14 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 fc42063..082430d 100644
--- a/internal/php5/php5.y
+++ b/internal/php5/php5.y
@@ -1431,6 +1431,7 @@ catch_statement:
yylex.(*Parser).setFreeFloating(catchNode, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(catchNode, token.Catch, $2.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $4.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(catchNode, token.Var, $5.Tokens)
yylex.(*Parser).setFreeFloating(catchNode, token.Cond, $6.Tokens)
yylex.(*Parser).setFreeFloating(catchNode, token.Stmts, $8.Tokens)
@@ -1508,6 +1509,7 @@ additional_catch:
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Catch, $2.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $4.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, $5.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Cond, $6.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Stmts, $8.Tokens)
@@ -2309,6 +2311,7 @@ parameter:
yylex.(*Parser).setFreeFloating($$, token.Ampersand, $3.Tokens)
}
yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
// normalize
if $3 == nil {
@@ -2354,6 +2357,7 @@ parameter:
}
yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Var, $5.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
// normalize
if $3 == nil {
@@ -2556,6 +2560,7 @@ global_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -2605,6 +2610,7 @@ static_var_list:
// save comments
yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(staticVar, token.Start, $3.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -2623,6 +2629,7 @@ static_var_list:
// save comments
yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(staticVar, token.Start, $3.Tokens)
yylex.(*Parser).setFreeFloating(staticVar, token.Var, $4.Tokens)
@@ -2641,6 +2648,7 @@ static_var_list:
staticVar.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenPosition($1)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(staticVar, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -2658,6 +2666,7 @@ static_var_list:
staticVar.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenNodePosition($1, $3)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(staticVar, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(staticVar, token.Var, $2.Tokens)
@@ -3155,6 +3164,7 @@ class_variable_declaration:
property.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenPosition($3)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(property, token.Start, $3.Tokens)
@@ -3174,6 +3184,7 @@ class_variable_declaration:
// save comments
yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(property, token.Start, $3.Tokens)
yylex.(*Parser).setFreeFloating(property, token.Var, $4.Tokens)
@@ -3192,6 +3203,7 @@ class_variable_declaration:
property.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenPosition($1)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(property, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -3209,6 +3221,7 @@ class_variable_declaration:
property.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokenNodePosition($1, $3)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(property, token.Start, $2.Tokens)
yylex.(*Parser).setFreeFloating(property, token.Var, $2.Tokens)
@@ -4589,6 +4602,7 @@ lexical_var_list:
// save comments
yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $3.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -4608,6 +4622,7 @@ lexical_var_list:
yylex.(*Parser).setFreeFloating(lastNode($1), token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(reference, token.Start, $3.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $4.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -4623,6 +4638,7 @@ lexical_var_list:
// save comments
yylex.(*Parser).setFreeFloating(variable, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -4641,6 +4657,7 @@ lexical_var_list:
// save comments
yylex.(*Parser).setFreeFloating(reference, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $2.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -6381,6 +6398,7 @@ compound_variable:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -6807,6 +6825,7 @@ encaps_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -6822,6 +6841,7 @@ encaps_var:
$$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $4)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, append($2.Tokens, yylex.(*Parser).GetFreeFloatingToken($2)...))
yylex.(*Parser).setFreeFloating($$, token.Expr, append($4.Tokens, yylex.(*Parser).GetFreeFloatingToken($4)...))
@@ -6841,6 +6861,7 @@ encaps_var:
$$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $3)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
yylex.(*Parser).setFreeFloating(fetch, token.Start, $3.Tokens)
@@ -6950,6 +6971,7 @@ encaps_var_offset:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
diff --git a/internal/php7/parser.go b/internal/php7/parser.go
index cb42f54..a960984 100644
--- a/internal/php7/parser.go
+++ b/internal/php7/parser.go
@@ -131,10 +131,25 @@ func (l *Parser) GetFreeFloatingToken(t *scanner.Token) []token.Token {
return []token.Token{}
}
- tokens := make([]token.Token, len(t.Tokens))
- copy(tokens, t.Tokens)
+ return []token.Token{
+ {
+ ID: token.ID(t.ID),
+ Value: t.Value,
+ },
+ }
+}
- return tokens
+func (l *Parser) addDollarToken(v ast.Vertex) {
+ if l.Lexer.GetWithFreeFloating() == false {
+ return
+ }
+
+ l.setFreeFloating(v, token.Dollar, []token.Token{
+ {
+ ID: token.ID('$'),
+ Value: []byte("$"),
+ },
+ })
}
func (l *Parser) splitSemiColonAndPhpCloseTag(htmlNode ast.Vertex, prevNode ast.Vertex) {
diff --git a/internal/php7/parser_test.go b/internal/php7/parser_test.go
index 25490fc..bceae9c 100644
--- a/internal/php7/parser_test.go
+++ b/internal/php7/parser_test.go
@@ -982,7 +982,7 @@ func TestPhp7ParameterNode(t *testing.T) {
EndPos: 51,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
FunctionName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -1183,7 +1183,7 @@ func TestPhp7ParameterNode(t *testing.T) {
EndPos: 117,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -1397,8 +1397,8 @@ func TestPhp7ParameterNode(t *testing.T) {
EndPos: 162,
},
},
- ReturnsRef: false,
- Static: false,
+ ReturnsRef: false,
+ Static: false,
Params: []ast.Vertex{
&ast.Parameter{
Node: ast.Node{
@@ -1577,8 +1577,8 @@ func TestPhp7ParameterNode(t *testing.T) {
EndPos: 214,
},
},
- Static: true,
- ReturnsRef: false,
+ Static: true,
+ ReturnsRef: false,
Params: []ast.Vertex{
&ast.Parameter{
Node: ast.Node{
@@ -4376,7 +4376,7 @@ func TestStmtClassMethod_SimpleClassMethod(t *testing.T) {
EndPos: 31,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -4454,7 +4454,7 @@ func TestStmtClassMethod_PrivateProtectedClassMethod(t *testing.T) {
EndPos: 45,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -4511,7 +4511,7 @@ func TestStmtClassMethod_PrivateProtectedClassMethod(t *testing.T) {
EndPos: 73,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -4602,7 +4602,7 @@ func TestStmtClassMethod_Php7ClassMethod(t *testing.T) {
EndPos: 52,
},
},
- ReturnsRef: true,
+ ReturnsRef: true,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -4740,7 +4740,7 @@ func TestStmtClassMethod_AbstractClassMethod(t *testing.T) {
EndPos: 54,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -4854,7 +4854,7 @@ func TestStmtClassMethod_Php7AbstractClassMethod(t *testing.T) {
EndPos: 51,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
MethodName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -7300,7 +7300,7 @@ func TestStmtFunction(t *testing.T) {
EndPos: 20,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
FunctionName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -7345,7 +7345,7 @@ func TestStmtFunction_Return(t *testing.T) {
EndPos: 27,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
FunctionName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -7401,7 +7401,7 @@ func TestStmtFunction_ReturnVar(t *testing.T) {
EndPos: 51,
},
},
- ReturnsRef: false,
+ ReturnsRef: false,
FunctionName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -7568,7 +7568,7 @@ func TestStmtFunction_Ref(t *testing.T) {
EndPos: 30,
},
},
- ReturnsRef: true,
+ ReturnsRef: true,
FunctionName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -7635,7 +7635,7 @@ func TestStmtFunction_ReturnType(t *testing.T) {
EndPos: 27,
},
},
- ReturnsRef: true,
+ ReturnsRef: true,
FunctionName: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
@@ -14535,8 +14535,8 @@ func TestExprArrowFunction(t *testing.T) {
EndPos: 13,
},
},
- ReturnsRef: false,
- Static: false,
+ ReturnsRef: false,
+ Static: false,
Expr: &ast.ExprVariable{
Node: ast.Node{
Position: &position.Position{
@@ -14600,8 +14600,8 @@ func TestExprArrowFunction_ReturnType(t *testing.T) {
EndPos: 22,
},
},
- Static: false,
- ReturnsRef: true,
+ Static: false,
+ ReturnsRef: true,
ReturnType: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@@ -15080,9 +15080,9 @@ func TestExprClosure(t *testing.T) {
EndPos: 15,
},
},
- ReturnsRef: false,
- Static: false,
- Stmts: []ast.Vertex{},
+ ReturnsRef: false,
+ Static: false,
+ Stmts: []ast.Vertex{},
},
},
},
@@ -15125,8 +15125,8 @@ func TestExprClosure_Use(t *testing.T) {
EndPos: 36,
},
},
- ReturnsRef: false,
- Static: false,
+ ReturnsRef: false,
+ Static: false,
Params: []ast.Vertex{
&ast.Parameter{
Node: ast.Node{
@@ -15302,8 +15302,8 @@ func TestExprClosure_Use2(t *testing.T) {
EndPos: 36,
},
},
- ReturnsRef: false,
- Static: false,
+ ReturnsRef: false,
+ Static: false,
Params: []ast.Vertex{
&ast.Parameter{
Node: ast.Node{
@@ -15479,8 +15479,8 @@ func TestExprClosure_ReturnType(t *testing.T) {
EndPos: 22,
},
},
- ReturnsRef: false,
- Static: false,
+ ReturnsRef: false,
+ Static: false,
ReturnType: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
diff --git a/internal/php7/php7.go b/internal/php7/php7.go
index 9a3f30a..0900ad3 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 9f08fa4..cd147ff 100644
--- a/internal/php7/php7.y
+++ b/internal/php7/php7.y
@@ -1368,6 +1368,7 @@ catch_list:
yylex.(*Parser).setFreeFloating(catch, token.Start, $2.Tokens)
yylex.(*Parser).setFreeFloating(catch, token.Catch, $3.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $5.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating(catch, token.Var, $6.Tokens)
yylex.(*Parser).setFreeFloating(catch, token.Cond, $7.Tokens)
yylex.(*Parser).setFreeFloating(catch, token.Stmts, $9.Tokens)
@@ -2172,6 +2173,8 @@ parameter:
}
yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
+
// normalize
if $3 == nil {
yylex.(*Parser).setFreeFloating($$, token.Ampersand, $$.GetNode().Tokens[token.Variadic]); delete($$.GetNode().Tokens, token.Variadic)
@@ -2217,6 +2220,8 @@ parameter:
yylex.(*Parser).setFreeFloating($$, token.Variadic, $4.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Var, $5.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
+
// normalize
if $3 == nil {
yylex.(*Parser).setFreeFloating($$, token.Ampersand, $$.GetNode().Tokens[token.Variadic]); delete($$.GetNode().Tokens, token.Variadic)
@@ -2456,6 +2461,7 @@ static_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -2472,6 +2478,7 @@ static_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -2981,6 +2988,7 @@ property:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -2997,6 +3005,7 @@ property:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@@ -4297,6 +4306,7 @@ lexical_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -4314,6 +4324,7 @@ lexical_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(variable, token.Start, $2.Tokens)
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -4943,6 +4954,7 @@ simple_variable:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -5352,6 +5364,7 @@ encaps_var:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@@ -5367,6 +5380,7 @@ encaps_var:
$$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $4)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, append($2.Tokens, yylex.(*Parser).GetFreeFloatingToken($2)...))
yylex.(*Parser).setFreeFloating($$, token.Expr, append($4.Tokens, yylex.(*Parser).GetFreeFloatingToken($4)...))
@@ -5386,6 +5400,7 @@ encaps_var:
$$.GetNode().Position = yylex.(*Parser).positionBuilder.NewTokensPosition($1, $3)
// save comments
+ yylex.(*Parser).addDollarToken(variable)
yylex.(*Parser).setFreeFloating($$, token.Var, $2.Tokens)
yylex.(*Parser).setFreeFloating(fetch, token.Start, $3.Tokens)
@@ -5521,6 +5536,7 @@ encaps_var_offset:
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
+ yylex.(*Parser).addDollarToken($$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
diff --git a/internal/scanner/scanner.go b/internal/scanner/scanner.go
index 3764cec..0d411e1 100644
Binary files a/internal/scanner/scanner.go and b/internal/scanner/scanner.go differ
diff --git a/internal/scanner/scanner.rl b/internal/scanner/scanner.rl
index 5eec481..d9195f2 100644
--- a/internal/scanner/scanner.rl
+++ b/internal/scanner/scanner.rl
@@ -510,6 +510,7 @@ func (lex *Lexer) Lex(lval Lval) int {
token.Tokens = lex.Tokens
token.Value = lex.data[lex.ts:lex.te]
+ token.ID = tok
lval.Token(token)
diff --git a/internal/scanner/token.go b/internal/scanner/token.go
index d45a12e..7c07126 100644
--- a/internal/scanner/token.go
+++ b/internal/scanner/token.go
@@ -6,6 +6,7 @@ import (
// Token value returned by lexer
type Token struct {
+ ID TokenID
Value []byte
Tokens []token.Token
StartLine int
diff --git a/pkg/ast/visitor/namespace_resolver.go b/pkg/ast/visitor/namespace_resolver.go
index f79378c..3029c5c 100644
--- a/pkg/ast/visitor/namespace_resolver.go
+++ b/pkg/ast/visitor/namespace_resolver.go
@@ -27,7 +27,7 @@ func NewNamespaceResolver() *NamespaceResolver {
func (nsr *NamespaceResolver) EnterNode(n ast.Vertex) bool {
n.Accept(nsr)
-
+
if !nsr.goDeep {
nsr.goDeep = true
return false
@@ -54,7 +54,7 @@ func (nsr *NamespaceResolver) StmtUseList(n *ast.StmtUseList) {
for _, nn := range n.Uses {
nsr.AddAlias(useType, nn, nil)
}
-
+
nsr.goDeep = false
}
diff --git a/pkg/ast/visitor/namespace_resolver_test.go b/pkg/ast/visitor/namespace_resolver_test.go
index 61ed537..607aa9e 100644
--- a/pkg/ast/visitor/namespace_resolver_test.go
+++ b/pkg/ast/visitor/namespace_resolver_test.go
@@ -194,8 +194,8 @@ func TestResolveInstanceCatch(t *testing.T) {
nameBC,
nameF,
},
- Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
- Stmts: []ast.Vertex{},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+ Stmts: []ast.Vertex{},
},
},
},
@@ -407,7 +407,7 @@ func TestResolveClassName(t *testing.T) {
nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
class := &ast.StmtClass{
- ClassName: &ast.Identifier{Value: []byte("A")},
+ ClassName: &ast.Identifier{Value: []byte("A")},
Extends: &ast.StmtClassExtends{
ClassName: nameAB,
},
@@ -472,8 +472,8 @@ func TestResolveInterfaceName(t *testing.T) {
func TestResolveTraitName(t *testing.T) {
traitNode := &ast.StmtTrait{
- TraitName: &ast.Identifier{Value: []byte("A")},
- Stmts: []ast.Vertex{},
+ TraitName: &ast.Identifier{Value: []byte("A")},
+ Stmts: []ast.Vertex{},
}
stxTree := &ast.StmtStmtList{
@@ -498,14 +498,14 @@ func TestResolveFunctionName(t *testing.T) {
nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
functionNode := &ast.StmtFunction{
- ReturnsRef: false,
- FunctionName: &ast.Identifier{Value: []byte("A")},
+ ReturnsRef: false,
+ FunctionName: &ast.Identifier{Value: []byte("A")},
Params: []ast.Vertex{
&ast.Parameter{
- ByRef: false,
- Variadic: false,
- Type: nameAB,
- Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+ ByRef: false,
+ Variadic: false,
+ Type: nameAB,
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
},
},
ReturnType: &ast.Nullable{Expr: nameBC},
@@ -536,14 +536,14 @@ func TestResolveMethodName(t *testing.T) {
nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
methodNode := &ast.StmtClassMethod{
- ReturnsRef: false,
- MethodName: &ast.Identifier{Value: []byte("A")},
+ ReturnsRef: false,
+ MethodName: &ast.Identifier{Value: []byte("A")},
Params: []ast.Vertex{
&ast.Parameter{
- ByRef: false,
- Variadic: false,
- Type: nameAB,
- Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+ ByRef: false,
+ Variadic: false,
+ Type: nameAB,
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
},
},
ReturnType: &ast.Nullable{Expr: nameBC},
@@ -569,14 +569,14 @@ func TestResolveClosureName(t *testing.T) {
nameBC := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("B")}, &ast.NameNamePart{Value: []byte("C")}}}
closureNode := &ast.ExprClosure{
- ReturnsRef: false,
- Static: false,
+ ReturnsRef: false,
+ Static: false,
Params: []ast.Vertex{
&ast.Parameter{
- ByRef: false,
- Variadic: false,
- Type: nameAB,
- Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+ ByRef: false,
+ Variadic: false,
+ Type: nameAB,
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
},
},
ClosureUse: nil,
@@ -600,12 +600,12 @@ func TestResolveConstantsName(t *testing.T) {
nameAB := &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("A")}, &ast.NameNamePart{Value: []byte("B")}}}
constantB := &ast.StmtConstant{
- ConstantName: &ast.Identifier{Value: []byte("B")},
- Expr: &ast.ScalarLnumber{Value: []byte("1")},
+ ConstantName: &ast.Identifier{Value: []byte("B")},
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
}
constantC := &ast.StmtConstant{
- ConstantName: &ast.Identifier{Value: []byte("C")},
- Expr: &ast.ScalarLnumber{Value: []byte("1")},
+ ConstantName: &ast.Identifier{Value: []byte("C")},
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
}
stxTree := &ast.StmtStmtList{
@@ -644,12 +644,12 @@ func TestResolveNamespaces(t *testing.T) {
relativeNameCE := &ast.NameRelative{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("C")}, &ast.NameNamePart{Value: []byte("E")}}}
constantB := &ast.StmtConstant{
- ConstantName: &ast.Identifier{Value: []byte("B")},
- Expr: &ast.ScalarLnumber{Value: []byte("1")},
+ ConstantName: &ast.Identifier{Value: []byte("B")},
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
}
constantC := &ast.StmtConstant{
- ConstantName: &ast.Identifier{Value: []byte("C")},
- Expr: &ast.ScalarLnumber{Value: []byte("1")},
+ ConstantName: &ast.Identifier{Value: []byte("C")},
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
}
stxTree := &ast.StmtStmtList{
diff --git a/printer/pretty_printer.go b/pkg/printer/pretty_printer.go
similarity index 54%
rename from printer/pretty_printer.go
rename to pkg/printer/pretty_printer.go
index 95de96f..37a1a71 100644
--- a/printer/pretty_printer.go
+++ b/pkg/printer/pretty_printer.go
@@ -4,15 +4,7 @@ import (
"io"
"strings"
- "github.com/z7zmey/php-parser/node/stmt"
-
- "github.com/z7zmey/php-parser/node"
- "github.com/z7zmey/php-parser/node/expr"
- "github.com/z7zmey/php-parser/node/expr/assign"
- "github.com/z7zmey/php-parser/node/expr/binary"
- "github.com/z7zmey/php-parser/node/expr/cast"
- "github.com/z7zmey/php-parser/node/name"
- "github.com/z7zmey/php-parser/node/scalar"
+ "github.com/z7zmey/php-parser/pkg/ast"
)
type PrettyPrinter struct {
@@ -30,11 +22,11 @@ func NewPrettyPrinter(w io.Writer, indentStr string) *PrettyPrinter {
}
}
-func (p *PrettyPrinter) Print(n node.Node) {
+func (p *PrettyPrinter) Print(n ast.Vertex) {
p.printNode(n)
}
-func (p *PrettyPrinter) joinPrint(glue string, nn []node.Node) {
+func (p *PrettyPrinter) joinPrint(glue string, nn []ast.Vertex) {
for k, n := range nn {
if k > 0 {
io.WriteString(p.w, glue)
@@ -44,7 +36,7 @@ func (p *PrettyPrinter) joinPrint(glue string, nn []node.Node) {
}
}
-func (p *PrettyPrinter) printNodes(nn []node.Node) {
+func (p *PrettyPrinter) printNodes(nn []ast.Vertex) {
p.indentDepth++
l := len(nn) - 1
for k, n := range nn {
@@ -63,367 +55,367 @@ func (p *PrettyPrinter) printIndent() {
}
}
-func (p *PrettyPrinter) printNode(n node.Node) {
+func (p *PrettyPrinter) printNode(n ast.Vertex) {
switch n.(type) {
// node
- case *node.Root:
+ case *ast.Root:
p.printNodeRoot(n)
- case *node.Identifier:
+ case *ast.Identifier:
p.printNodeIdentifier(n)
- case *node.Parameter:
+ case *ast.Parameter:
p.printNodeParameter(n)
- case *node.Nullable:
+ case *ast.Nullable:
p.printNodeNullable(n)
- case *node.Argument:
+ case *ast.Argument:
p.printNodeArgument(n)
// name
- case *name.NamePart:
+ case *ast.NameNamePart:
p.printNameNamePart(n)
- case *name.Name:
+ case *ast.NameName:
p.printNameName(n)
- case *name.FullyQualified:
+ case *ast.NameFullyQualified:
p.printNameFullyQualified(n)
- case *name.Relative:
+ case *ast.NameRelative:
p.printNameRelative(n)
// scalar
- case *scalar.Lnumber:
+ case *ast.ScalarLnumber:
p.printScalarLNumber(n)
- case *scalar.Dnumber:
+ case *ast.ScalarDnumber:
p.printScalarDNumber(n)
- case *scalar.String:
+ case *ast.ScalarString:
p.printScalarString(n)
- case *scalar.EncapsedStringPart:
+ case *ast.ScalarEncapsedStringPart:
p.printScalarEncapsedStringPart(n)
- case *scalar.Encapsed:
+ case *ast.ScalarEncapsed:
p.printScalarEncapsed(n)
- case *scalar.Heredoc:
+ case *ast.ScalarHeredoc:
p.printScalarHeredoc(n)
- case *scalar.MagicConstant:
+ case *ast.ScalarMagicConstant:
p.printScalarMagicConstant(n)
// assign
- case *assign.Assign:
- p.printAssign(n)
- case *assign.Reference:
- p.printReference(n)
- case *assign.BitwiseAnd:
+ case *ast.ExprAssign:
+ p.printAssignAssign(n)
+ case *ast.ExprAssignReference:
+ p.printAssignReference(n)
+ case *ast.ExprAssignBitwiseAnd:
p.printAssignBitwiseAnd(n)
- case *assign.BitwiseOr:
+ case *ast.ExprAssignBitwiseOr:
p.printAssignBitwiseOr(n)
- case *assign.BitwiseXor:
+ case *ast.ExprAssignBitwiseXor:
p.printAssignBitwiseXor(n)
- case *assign.Concat:
+ case *ast.ExprAssignConcat:
p.printAssignConcat(n)
- case *assign.Div:
+ case *ast.ExprAssignDiv:
p.printAssignDiv(n)
- case *assign.Minus:
+ case *ast.ExprAssignMinus:
p.printAssignMinus(n)
- case *assign.Mod:
+ case *ast.ExprAssignMod:
p.printAssignMod(n)
- case *assign.Mul:
+ case *ast.ExprAssignMul:
p.printAssignMul(n)
- case *assign.Plus:
+ case *ast.ExprAssignPlus:
p.printAssignPlus(n)
- case *assign.Pow:
+ case *ast.ExprAssignPow:
p.printAssignPow(n)
- case *assign.ShiftLeft:
+ case *ast.ExprAssignShiftLeft:
p.printAssignShiftLeft(n)
- case *assign.ShiftRight:
+ case *ast.ExprAssignShiftRight:
p.printAssignShiftRight(n)
// binary
- case *binary.BitwiseAnd:
+ case *ast.ExprBinaryBitwiseAnd:
p.printBinaryBitwiseAnd(n)
- case *binary.BitwiseOr:
+ case *ast.ExprBinaryBitwiseOr:
p.printBinaryBitwiseOr(n)
- case *binary.BitwiseXor:
+ case *ast.ExprBinaryBitwiseXor:
p.printBinaryBitwiseXor(n)
- case *binary.BooleanAnd:
+ case *ast.ExprBinaryBooleanAnd:
p.printBinaryBooleanAnd(n)
- case *binary.BooleanOr:
+ case *ast.ExprBinaryBooleanOr:
p.printBinaryBooleanOr(n)
- case *binary.Coalesce:
+ case *ast.ExprBinaryCoalesce:
p.printBinaryCoalesce(n)
- case *binary.Concat:
+ case *ast.ExprBinaryConcat:
p.printBinaryConcat(n)
- case *binary.Div:
+ case *ast.ExprBinaryDiv:
p.printBinaryDiv(n)
- case *binary.Equal:
+ case *ast.ExprBinaryEqual:
p.printBinaryEqual(n)
- case *binary.GreaterOrEqual:
+ case *ast.ExprBinaryGreaterOrEqual:
p.printBinaryGreaterOrEqual(n)
- case *binary.Greater:
+ case *ast.ExprBinaryGreater:
p.printBinaryGreater(n)
- case *binary.Identical:
+ case *ast.ExprBinaryIdentical:
p.printBinaryIdentical(n)
- case *binary.LogicalAnd:
+ case *ast.ExprBinaryLogicalAnd:
p.printBinaryLogicalAnd(n)
- case *binary.LogicalOr:
+ case *ast.ExprBinaryLogicalOr:
p.printBinaryLogicalOr(n)
- case *binary.LogicalXor:
+ case *ast.ExprBinaryLogicalXor:
p.printBinaryLogicalXor(n)
- case *binary.Minus:
+ case *ast.ExprBinaryMinus:
p.printBinaryMinus(n)
- case *binary.Mod:
+ case *ast.ExprBinaryMod:
p.printBinaryMod(n)
- case *binary.Mul:
+ case *ast.ExprBinaryMul:
p.printBinaryMul(n)
- case *binary.NotEqual:
+ case *ast.ExprBinaryNotEqual:
p.printBinaryNotEqual(n)
- case *binary.NotIdentical:
+ case *ast.ExprBinaryNotIdentical:
p.printBinaryNotIdentical(n)
- case *binary.Plus:
+ case *ast.ExprBinaryPlus:
p.printBinaryPlus(n)
- case *binary.Pow:
+ case *ast.ExprBinaryPow:
p.printBinaryPow(n)
- case *binary.ShiftLeft:
+ case *ast.ExprBinaryShiftLeft:
p.printBinaryShiftLeft(n)
- case *binary.ShiftRight:
+ case *ast.ExprBinaryShiftRight:
p.printBinaryShiftRight(n)
- case *binary.SmallerOrEqual:
+ case *ast.ExprBinarySmallerOrEqual:
p.printBinarySmallerOrEqual(n)
- case *binary.Smaller:
+ case *ast.ExprBinarySmaller:
p.printBinarySmaller(n)
- case *binary.Spaceship:
+ case *ast.ExprBinarySpaceship:
p.printBinarySpaceship(n)
// cast
- case *cast.Array:
+ case *ast.ExprCastArray:
p.printArray(n)
- case *cast.Bool:
+ case *ast.ExprCastBool:
p.printBool(n)
- case *cast.Double:
+ case *ast.ExprCastDouble:
p.printDouble(n)
- case *cast.Int:
+ case *ast.ExprCastInt:
p.printInt(n)
- case *cast.Object:
+ case *ast.ExprCastObject:
p.printObject(n)
- case *cast.String:
+ case *ast.ExprCastString:
p.printString(n)
- case *cast.Unset:
+ case *ast.ExprCastUnset:
p.printUnset(n)
// expr
- case *expr.ArrayDimFetch:
+ case *ast.ExprArrayDimFetch:
p.printExprArrayDimFetch(n)
- case *expr.ArrayItem:
+ case *ast.ExprArrayItem:
p.printExprArrayItem(n)
- case *expr.Array:
+ case *ast.ExprArray:
p.printExprArray(n)
- case *expr.BitwiseNot:
+ case *ast.ExprBitwiseNot:
p.printExprBitwiseNot(n)
- case *expr.BooleanNot:
+ case *ast.ExprBooleanNot:
p.printExprBooleanNot(n)
- case *expr.ClassConstFetch:
+ case *ast.ExprClassConstFetch:
p.printExprClassConstFetch(n)
- case *expr.Clone:
+ case *ast.ExprClone:
p.printExprClone(n)
- case *expr.ClosureUse:
+ case *ast.ExprClosureUse:
p.printExprClosureUse(n)
- case *expr.Closure:
+ case *ast.ExprClosure:
p.printExprClosure(n)
- case *expr.ConstFetch:
+ case *ast.ExprConstFetch:
p.printExprConstFetch(n)
- case *expr.Empty:
+ case *ast.ExprEmpty:
p.printExprEmpty(n)
- case *expr.ErrorSuppress:
+ case *ast.ExprErrorSuppress:
p.printExprErrorSuppress(n)
- case *expr.Eval:
+ case *ast.ExprEval:
p.printExprEval(n)
- case *expr.Exit:
+ case *ast.ExprExit:
p.printExprExit(n)
- case *expr.FunctionCall:
+ case *ast.ExprFunctionCall:
p.printExprFunctionCall(n)
- case *expr.Include:
+ case *ast.ExprInclude:
p.printExprInclude(n)
- case *expr.IncludeOnce:
+ case *ast.ExprIncludeOnce:
p.printExprIncludeOnce(n)
- case *expr.InstanceOf:
+ case *ast.ExprInstanceOf:
p.printExprInstanceOf(n)
- case *expr.Isset:
+ case *ast.ExprIsset:
p.printExprIsset(n)
- case *expr.List:
+ case *ast.ExprList:
p.printExprList(n)
- case *expr.MethodCall:
+ case *ast.ExprMethodCall:
p.printExprMethodCall(n)
- case *expr.New:
+ case *ast.ExprNew:
p.printExprNew(n)
- case *expr.PostDec:
+ case *ast.ExprPostDec:
p.printExprPostDec(n)
- case *expr.PostInc:
+ case *ast.ExprPostInc:
p.printExprPostInc(n)
- case *expr.PreDec:
+ case *ast.ExprPreDec:
p.printExprPreDec(n)
- case *expr.PreInc:
+ case *ast.ExprPreInc:
p.printExprPreInc(n)
- case *expr.Print:
+ case *ast.ExprPrint:
p.printExprPrint(n)
- case *expr.PropertyFetch:
+ case *ast.ExprPropertyFetch:
p.printExprPropertyFetch(n)
- case *expr.Reference:
+ case *ast.ExprReference:
p.printExprReference(n)
- case *expr.Require:
+ case *ast.ExprRequire:
p.printExprRequire(n)
- case *expr.RequireOnce:
+ case *ast.ExprRequireOnce:
p.printExprRequireOnce(n)
- case *expr.ShellExec:
+ case *ast.ExprShellExec:
p.printExprShellExec(n)
- case *expr.ShortArray:
+ case *ast.ExprShortArray:
p.printExprShortArray(n)
- case *expr.ShortList:
+ case *ast.ExprShortList:
p.printExprShortList(n)
- case *expr.StaticCall:
+ case *ast.ExprStaticCall:
p.printExprStaticCall(n)
- case *expr.StaticPropertyFetch:
+ case *ast.ExprStaticPropertyFetch:
p.printExprStaticPropertyFetch(n)
- case *expr.Ternary:
+ case *ast.ExprTernary:
p.printExprTernary(n)
- case *expr.UnaryMinus:
+ case *ast.ExprUnaryMinus:
p.printExprUnaryMinus(n)
- case *expr.UnaryPlus:
+ case *ast.ExprUnaryPlus:
p.printExprUnaryPlus(n)
- case *expr.Variable:
+ case *ast.ExprVariable:
p.printExprVariable(n)
- case *expr.YieldFrom:
+ case *ast.ExprYieldFrom:
p.printExprYieldFrom(n)
- case *expr.Yield:
+ case *ast.ExprYield:
p.printExprYield(n)
// stmt
- case *stmt.AltElseIf:
+ case *ast.StmtAltElseIf:
p.printStmtAltElseIf(n)
- case *stmt.AltElse:
+ case *ast.StmtAltElse:
p.printStmtAltElse(n)
- case *stmt.AltFor:
+ case *ast.StmtAltFor:
p.printStmtAltFor(n)
- case *stmt.AltForeach:
+ case *ast.StmtAltForeach:
p.printStmtAltForeach(n)
- case *stmt.AltIf:
+ case *ast.StmtAltIf:
p.printStmtAltIf(n)
- case *stmt.AltSwitch:
+ case *ast.StmtAltSwitch:
p.printStmtAltSwitch(n)
- case *stmt.AltWhile:
+ case *ast.StmtAltWhile:
p.printStmtAltWhile(n)
- case *stmt.Break:
+ case *ast.StmtBreak:
p.printStmtBreak(n)
- case *stmt.Case:
+ case *ast.StmtCase:
p.printStmtCase(n)
- case *stmt.Catch:
+ case *ast.StmtCatch:
p.printStmtCatch(n)
- case *stmt.ClassMethod:
+ case *ast.StmtClassMethod:
p.printStmtClassMethod(n)
- case *stmt.Class:
+ case *ast.StmtClass:
p.printStmtClass(n)
- case *stmt.ClassConstList:
+ case *ast.StmtClassConstList:
p.printStmtClassConstList(n)
- case *stmt.Constant:
+ case *ast.StmtConstant:
p.printStmtConstant(n)
- case *stmt.Continue:
+ case *ast.StmtContinue:
p.printStmtContinue(n)
- case *stmt.Declare:
+ case *ast.StmtDeclare:
p.printStmtDeclare(n)
- case *stmt.Default:
+ case *ast.StmtDefault:
p.printStmtDefault(n)
- case *stmt.Do:
+ case *ast.StmtDo:
p.printStmtDo(n)
- case *stmt.Echo:
+ case *ast.StmtEcho:
p.printStmtEcho(n)
- case *stmt.ElseIf:
+ case *ast.StmtElseIf:
p.printStmtElseif(n)
- case *stmt.Else:
+ case *ast.StmtElse:
p.printStmtElse(n)
- case *stmt.Expression:
+ case *ast.StmtExpression:
p.printStmtExpression(n)
- case *stmt.Finally:
+ case *ast.StmtFinally:
p.printStmtFinally(n)
- case *stmt.For:
+ case *ast.StmtFor:
p.printStmtFor(n)
- case *stmt.Foreach:
+ case *ast.StmtForeach:
p.printStmtForeach(n)
- case *stmt.Function:
+ case *ast.StmtFunction:
p.printStmtFunction(n)
- case *stmt.Global:
+ case *ast.StmtGlobal:
p.printStmtGlobal(n)
- case *stmt.Goto:
+ case *ast.StmtGoto:
p.printStmtGoto(n)
- case *stmt.GroupUse:
+ case *ast.StmtGroupUse:
p.printStmtGroupUse(n)
- case *stmt.HaltCompiler:
+ case *ast.StmtHaltCompiler:
p.printStmtHaltCompiler(n)
- case *stmt.If:
+ case *ast.StmtIf:
p.printStmtIf(n)
- case *stmt.InlineHtml:
+ case *ast.StmtInlineHtml:
p.printStmtInlineHTML(n)
- case *stmt.Interface:
+ case *ast.StmtInterface:
p.printStmtInterface(n)
- case *stmt.Label:
+ case *ast.StmtLabel:
p.printStmtLabel(n)
- case *stmt.Namespace:
+ case *ast.StmtNamespace:
p.printStmtNamespace(n)
- case *stmt.Nop:
+ case *ast.StmtNop:
p.printStmtNop(n)
- case *stmt.PropertyList:
+ case *ast.StmtPropertyList:
p.printStmtPropertyList(n)
- case *stmt.Property:
+ case *ast.StmtProperty:
p.printStmtProperty(n)
- case *stmt.Return:
+ case *ast.StmtReturn:
p.printStmtReturn(n)
- case *stmt.StaticVar:
+ case *ast.StmtStaticVar:
p.printStmtStaticVar(n)
- case *stmt.Static:
+ case *ast.StmtStatic:
p.printStmtStatic(n)
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
p.printStmtStmtList(n)
- case *stmt.Switch:
+ case *ast.StmtSwitch:
p.printStmtSwitch(n)
- case *stmt.Throw:
+ case *ast.StmtThrow:
p.printStmtThrow(n)
- case *stmt.TraitMethodRef:
+ case *ast.StmtTraitMethodRef:
p.printStmtTraitMethodRef(n)
- case *stmt.TraitUseAlias:
+ case *ast.StmtTraitUseAlias:
p.printStmtTraitUseAlias(n)
- case *stmt.TraitUsePrecedence:
+ case *ast.StmtTraitUsePrecedence:
p.printStmtTraitUsePrecedence(n)
- case *stmt.TraitUse:
+ case *ast.StmtTraitUse:
p.printStmtTraitUse(n)
- case *stmt.Trait:
+ case *ast.StmtTrait:
p.printStmtTrait(n)
- case *stmt.Try:
+ case *ast.StmtTry:
p.printStmtTry(n)
- case *stmt.Unset:
+ case *ast.StmtUnset:
p.printStmtUnset(n)
- case *stmt.UseList:
+ case *ast.StmtUseList:
p.printStmtUseList(n)
- case *stmt.Use:
+ case *ast.StmtUse:
p.printStmtUse(n)
- case *stmt.While:
+ case *ast.StmtWhile:
p.printStmtWhile(n)
}
}
// node
-func (p *PrettyPrinter) printNodeRoot(n node.Node) {
- v := n.(*node.Root)
+func (p *PrettyPrinter) printNodeRoot(n ast.Vertex) {
+ v := n.(*ast.Root)
if len(v.Stmts) > 0 {
firstStmt := v.Stmts[0]
v.Stmts = v.Stmts[1:]
switch fs := firstStmt.(type) {
- case *stmt.InlineHtml:
- io.WriteString(p.w, fs.Value)
+ case *ast.StmtInlineHtml:
+ io.WriteString(p.w, string(fs.Value))
io.WriteString(p.w, " 0 {
@@ -506,8 +498,8 @@ func (p *PrettyPrinter) printNameName(n node.Node) {
}
}
-func (p *PrettyPrinter) printNameFullyQualified(n node.Node) {
- nn := n.(*name.FullyQualified)
+func (p *PrettyPrinter) printNameFullyQualified(n ast.Vertex) {
+ nn := n.(*ast.NameFullyQualified)
for _, part := range nn.Parts {
io.WriteString(p.w, "\\")
@@ -515,8 +507,8 @@ func (p *PrettyPrinter) printNameFullyQualified(n node.Node) {
}
}
-func (p *PrettyPrinter) printNameRelative(n node.Node) {
- nn := n.(*name.Relative)
+func (p *PrettyPrinter) printNameRelative(n ast.Vertex) {
+ nn := n.(*ast.NameRelative)
io.WriteString(p.w, "namespace")
for _, part := range nn.Parts {
@@ -527,34 +519,34 @@ func (p *PrettyPrinter) printNameRelative(n node.Node) {
// scalar
-func (p *PrettyPrinter) printScalarLNumber(n node.Node) {
- v := n.(*scalar.Lnumber).Value
+func (p *PrettyPrinter) printScalarLNumber(n ast.Vertex) {
+ v := string(n.(*ast.ScalarLnumber).Value)
io.WriteString(p.w, v)
}
-func (p *PrettyPrinter) printScalarDNumber(n node.Node) {
- v := n.(*scalar.Dnumber).Value
+func (p *PrettyPrinter) printScalarDNumber(n ast.Vertex) {
+ v := string(n.(*ast.ScalarDnumber).Value)
io.WriteString(p.w, v)
}
-func (p *PrettyPrinter) printScalarString(n node.Node) {
- v := n.(*scalar.String).Value
+func (p *PrettyPrinter) printScalarString(n ast.Vertex) {
+ v := string(n.(*ast.ScalarString).Value)
io.WriteString(p.w, v)
}
-func (p *PrettyPrinter) printScalarEncapsedStringPart(n node.Node) {
- v := n.(*scalar.EncapsedStringPart).Value
+func (p *PrettyPrinter) printScalarEncapsedStringPart(n ast.Vertex) {
+ v := string(n.(*ast.ScalarEncapsedStringPart).Value)
io.WriteString(p.w, v)
}
-func (p *PrettyPrinter) printScalarEncapsed(n node.Node) {
- nn := n.(*scalar.Encapsed)
+func (p *PrettyPrinter) printScalarEncapsed(n ast.Vertex) {
+ nn := n.(*ast.ScalarEncapsed)
io.WriteString(p.w, "\"")
for _, part := range nn.Parts {
switch part.(type) {
- case *scalar.EncapsedStringPart:
+ case *ast.ScalarEncapsedStringPart:
p.Print(part)
default:
io.WriteString(p.w, "{")
@@ -566,14 +558,14 @@ func (p *PrettyPrinter) printScalarEncapsed(n node.Node) {
io.WriteString(p.w, "\"")
}
-func (p *PrettyPrinter) printScalarHeredoc(n node.Node) {
- nn := n.(*scalar.Heredoc)
+func (p *PrettyPrinter) printScalarHeredoc(n ast.Vertex) {
+ nn := n.(*ast.ScalarHeredoc)
- io.WriteString(p.w, nn.Label)
+ io.WriteString(p.w, string(nn.Label))
for _, part := range nn.Parts {
switch part.(type) {
- case *scalar.EncapsedStringPart:
+ case *ast.ScalarEncapsedStringPart:
p.Print(part)
default:
io.WriteString(p.w, "{")
@@ -582,326 +574,326 @@ func (p *PrettyPrinter) printScalarHeredoc(n node.Node) {
}
}
- io.WriteString(p.w, strings.Trim(nn.Label, "<\"'\n"))
+ io.WriteString(p.w, strings.Trim(string(nn.Label), "<\"'\n"))
}
-func (p *PrettyPrinter) printScalarMagicConstant(n node.Node) {
- v := n.(*scalar.MagicConstant).Value
+func (p *PrettyPrinter) printScalarMagicConstant(n ast.Vertex) {
+ v := string(n.(*ast.ScalarMagicConstant).Value)
io.WriteString(p.w, v)
}
// Assign
-func (p *PrettyPrinter) printAssign(n node.Node) {
- nn := n.(*assign.Assign)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignAssign(n ast.Vertex) {
+ nn := n.(*ast.ExprAssign)
+ p.Print(nn.Var)
io.WriteString(p.w, " = ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printReference(n node.Node) {
- nn := n.(*assign.Reference)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignReference(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignReference)
+ p.Print(nn.Var)
io.WriteString(p.w, " =& ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignBitwiseAnd(n node.Node) {
- nn := n.(*assign.BitwiseAnd)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignBitwiseAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignBitwiseAnd)
+ p.Print(nn.Var)
io.WriteString(p.w, " &= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignBitwiseOr(n node.Node) {
- nn := n.(*assign.BitwiseOr)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignBitwiseOr(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignBitwiseOr)
+ p.Print(nn.Var)
io.WriteString(p.w, " |= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignBitwiseXor(n node.Node) {
- nn := n.(*assign.BitwiseXor)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignBitwiseXor(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignBitwiseXor)
+ p.Print(nn.Var)
io.WriteString(p.w, " ^= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignConcat(n node.Node) {
- nn := n.(*assign.Concat)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignConcat(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignConcat)
+ p.Print(nn.Var)
io.WriteString(p.w, " .= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignDiv(n node.Node) {
- nn := n.(*assign.Div)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignDiv(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignDiv)
+ p.Print(nn.Var)
io.WriteString(p.w, " /= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignMinus(n node.Node) {
- nn := n.(*assign.Minus)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignMinus(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignMinus)
+ p.Print(nn.Var)
io.WriteString(p.w, " -= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignMod(n node.Node) {
- nn := n.(*assign.Mod)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignMod(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignMod)
+ p.Print(nn.Var)
io.WriteString(p.w, " %= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignMul(n node.Node) {
- nn := n.(*assign.Mul)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignMul(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignMul)
+ p.Print(nn.Var)
io.WriteString(p.w, " *= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignPlus(n node.Node) {
- nn := n.(*assign.Plus)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignPlus(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignPlus)
+ p.Print(nn.Var)
io.WriteString(p.w, " += ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignPow(n node.Node) {
- nn := n.(*assign.Pow)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignPow(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignPow)
+ p.Print(nn.Var)
io.WriteString(p.w, " **= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignShiftLeft(n node.Node) {
- nn := n.(*assign.ShiftLeft)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignShiftLeft(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignShiftLeft)
+ p.Print(nn.Var)
io.WriteString(p.w, " <<= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printAssignShiftRight(n node.Node) {
- nn := n.(*assign.ShiftRight)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printAssignShiftRight(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignShiftRight)
+ p.Print(nn.Var)
io.WriteString(p.w, " >>= ")
- p.Print(nn.Expression)
+ p.Print(nn.Expr)
}
// binary
-func (p *PrettyPrinter) printBinaryBitwiseAnd(n node.Node) {
- nn := n.(*binary.BitwiseAnd)
+func (p *PrettyPrinter) printBinaryBitwiseAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBitwiseAnd)
p.Print(nn.Left)
io.WriteString(p.w, " & ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryBitwiseOr(n node.Node) {
- nn := n.(*binary.BitwiseOr)
+func (p *PrettyPrinter) printBinaryBitwiseOr(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBitwiseOr)
p.Print(nn.Left)
io.WriteString(p.w, " | ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryBitwiseXor(n node.Node) {
- nn := n.(*binary.BitwiseXor)
+func (p *PrettyPrinter) printBinaryBitwiseXor(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBitwiseXor)
p.Print(nn.Left)
io.WriteString(p.w, " ^ ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryBooleanAnd(n node.Node) {
- nn := n.(*binary.BooleanAnd)
+func (p *PrettyPrinter) printBinaryBooleanAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBooleanAnd)
p.Print(nn.Left)
io.WriteString(p.w, " && ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryBooleanOr(n node.Node) {
- nn := n.(*binary.BooleanOr)
+func (p *PrettyPrinter) printBinaryBooleanOr(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBooleanOr)
p.Print(nn.Left)
io.WriteString(p.w, " || ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryCoalesce(n node.Node) {
- nn := n.(*binary.Coalesce)
+func (p *PrettyPrinter) printBinaryCoalesce(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryCoalesce)
p.Print(nn.Left)
io.WriteString(p.w, " ?? ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryConcat(n node.Node) {
- nn := n.(*binary.Concat)
+func (p *PrettyPrinter) printBinaryConcat(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryConcat)
p.Print(nn.Left)
io.WriteString(p.w, " . ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryDiv(n node.Node) {
- nn := n.(*binary.Div)
+func (p *PrettyPrinter) printBinaryDiv(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryDiv)
p.Print(nn.Left)
io.WriteString(p.w, " / ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryEqual(n node.Node) {
- nn := n.(*binary.Equal)
+func (p *PrettyPrinter) printBinaryEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryEqual)
p.Print(nn.Left)
io.WriteString(p.w, " == ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryGreaterOrEqual(n node.Node) {
- nn := n.(*binary.GreaterOrEqual)
+func (p *PrettyPrinter) printBinaryGreaterOrEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryGreaterOrEqual)
p.Print(nn.Left)
io.WriteString(p.w, " >= ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryGreater(n node.Node) {
- nn := n.(*binary.Greater)
+func (p *PrettyPrinter) printBinaryGreater(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryGreater)
p.Print(nn.Left)
io.WriteString(p.w, " > ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryIdentical(n node.Node) {
- nn := n.(*binary.Identical)
+func (p *PrettyPrinter) printBinaryIdentical(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryIdentical)
p.Print(nn.Left)
io.WriteString(p.w, " === ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryLogicalAnd(n node.Node) {
- nn := n.(*binary.LogicalAnd)
+func (p *PrettyPrinter) printBinaryLogicalAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryLogicalAnd)
p.Print(nn.Left)
io.WriteString(p.w, " and ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryLogicalOr(n node.Node) {
- nn := n.(*binary.LogicalOr)
+func (p *PrettyPrinter) printBinaryLogicalOr(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryLogicalOr)
p.Print(nn.Left)
io.WriteString(p.w, " or ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryLogicalXor(n node.Node) {
- nn := n.(*binary.LogicalXor)
+func (p *PrettyPrinter) printBinaryLogicalXor(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryLogicalXor)
p.Print(nn.Left)
io.WriteString(p.w, " xor ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryMinus(n node.Node) {
- nn := n.(*binary.Minus)
+func (p *PrettyPrinter) printBinaryMinus(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryMinus)
p.Print(nn.Left)
io.WriteString(p.w, " - ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryMod(n node.Node) {
- nn := n.(*binary.Mod)
+func (p *PrettyPrinter) printBinaryMod(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryMod)
p.Print(nn.Left)
io.WriteString(p.w, " % ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryMul(n node.Node) {
- nn := n.(*binary.Mul)
+func (p *PrettyPrinter) printBinaryMul(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryMul)
p.Print(nn.Left)
io.WriteString(p.w, " * ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryNotEqual(n node.Node) {
- nn := n.(*binary.NotEqual)
+func (p *PrettyPrinter) printBinaryNotEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryNotEqual)
p.Print(nn.Left)
io.WriteString(p.w, " != ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryNotIdentical(n node.Node) {
- nn := n.(*binary.NotIdentical)
+func (p *PrettyPrinter) printBinaryNotIdentical(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryNotIdentical)
p.Print(nn.Left)
io.WriteString(p.w, " !== ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryPlus(n node.Node) {
- nn := n.(*binary.Plus)
+func (p *PrettyPrinter) printBinaryPlus(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryPlus)
p.Print(nn.Left)
io.WriteString(p.w, " + ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryPow(n node.Node) {
- nn := n.(*binary.Pow)
+func (p *PrettyPrinter) printBinaryPow(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryPow)
p.Print(nn.Left)
io.WriteString(p.w, " ** ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryShiftLeft(n node.Node) {
- nn := n.(*binary.ShiftLeft)
+func (p *PrettyPrinter) printBinaryShiftLeft(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryShiftLeft)
p.Print(nn.Left)
io.WriteString(p.w, " << ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinaryShiftRight(n node.Node) {
- nn := n.(*binary.ShiftRight)
+func (p *PrettyPrinter) printBinaryShiftRight(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryShiftRight)
p.Print(nn.Left)
io.WriteString(p.w, " >> ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinarySmallerOrEqual(n node.Node) {
- nn := n.(*binary.SmallerOrEqual)
+func (p *PrettyPrinter) printBinarySmallerOrEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinarySmallerOrEqual)
p.Print(nn.Left)
io.WriteString(p.w, " <= ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinarySmaller(n node.Node) {
- nn := n.(*binary.Smaller)
+func (p *PrettyPrinter) printBinarySmaller(n ast.Vertex) {
+ nn := n.(*ast.ExprBinarySmaller)
p.Print(nn.Left)
io.WriteString(p.w, " < ")
p.Print(nn.Right)
}
-func (p *PrettyPrinter) printBinarySpaceship(n node.Node) {
- nn := n.(*binary.Spaceship)
+func (p *PrettyPrinter) printBinarySpaceship(n ast.Vertex) {
+ nn := n.(*ast.ExprBinarySpaceship)
p.Print(nn.Left)
io.WriteString(p.w, " <=> ")
@@ -910,50 +902,50 @@ func (p *PrettyPrinter) printBinarySpaceship(n node.Node) {
// cast
-func (p *PrettyPrinter) printArray(n node.Node) {
- nn := n.(*cast.Array)
+func (p *PrettyPrinter) printArray(n ast.Vertex) {
+ nn := n.(*ast.ExprCastArray)
io.WriteString(p.w, "(array)")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printBool(n node.Node) {
- nn := n.(*cast.Bool)
+func (p *PrettyPrinter) printBool(n ast.Vertex) {
+ nn := n.(*ast.ExprCastBool)
io.WriteString(p.w, "(bool)")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printDouble(n node.Node) {
- nn := n.(*cast.Double)
+func (p *PrettyPrinter) printDouble(n ast.Vertex) {
+ nn := n.(*ast.ExprCastDouble)
io.WriteString(p.w, "(float)")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printInt(n node.Node) {
- nn := n.(*cast.Int)
+func (p *PrettyPrinter) printInt(n ast.Vertex) {
+ nn := n.(*ast.ExprCastInt)
io.WriteString(p.w, "(int)")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printObject(n node.Node) {
- nn := n.(*cast.Object)
+func (p *PrettyPrinter) printObject(n ast.Vertex) {
+ nn := n.(*ast.ExprCastObject)
io.WriteString(p.w, "(object)")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printString(n node.Node) {
- nn := n.(*cast.String)
+func (p *PrettyPrinter) printString(n ast.Vertex) {
+ nn := n.(*ast.ExprCastString)
io.WriteString(p.w, "(string)")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printUnset(n node.Node) {
- nn := n.(*cast.Unset)
+func (p *PrettyPrinter) printUnset(n ast.Vertex) {
+ nn := n.(*ast.ExprCastUnset)
io.WriteString(p.w, "(unset)")
p.Print(nn.Expr)
@@ -961,16 +953,16 @@ func (p *PrettyPrinter) printUnset(n node.Node) {
// expr
-func (p *PrettyPrinter) printExprArrayDimFetch(n node.Node) {
- nn := n.(*expr.ArrayDimFetch)
- p.Print(nn.Variable)
+func (p *PrettyPrinter) printExprArrayDimFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprArrayDimFetch)
+ p.Print(nn.Var)
io.WriteString(p.w, "[")
p.Print(nn.Dim)
io.WriteString(p.w, "]")
}
-func (p *PrettyPrinter) printExprArrayItem(n node.Node) {
- nn := n.(*expr.ArrayItem)
+func (p *PrettyPrinter) printExprArrayItem(n ast.Vertex) {
+ nn := n.(*ast.ExprArrayItem)
if nn.Key != nil {
p.Print(nn.Key)
@@ -980,51 +972,51 @@ func (p *PrettyPrinter) printExprArrayItem(n node.Node) {
p.Print(nn.Val)
}
-func (p *PrettyPrinter) printExprArray(n node.Node) {
- nn := n.(*expr.Array)
+func (p *PrettyPrinter) printExprArray(n ast.Vertex) {
+ nn := n.(*ast.ExprArray)
io.WriteString(p.w, "array(")
p.joinPrint(", ", nn.Items)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprBitwiseNot(n node.Node) {
- nn := n.(*expr.BitwiseNot)
+func (p *PrettyPrinter) printExprBitwiseNot(n ast.Vertex) {
+ nn := n.(*ast.ExprBitwiseNot)
io.WriteString(p.w, "~")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprBooleanNot(n node.Node) {
- nn := n.(*expr.BooleanNot)
+func (p *PrettyPrinter) printExprBooleanNot(n ast.Vertex) {
+ nn := n.(*ast.ExprBooleanNot)
io.WriteString(p.w, "!")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprClassConstFetch(n node.Node) {
- nn := n.(*expr.ClassConstFetch)
+func (p *PrettyPrinter) printExprClassConstFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprClassConstFetch)
p.Print(nn.Class)
io.WriteString(p.w, "::")
- io.WriteString(p.w, nn.ConstantName.(*node.Identifier).Value)
+ io.WriteString(p.w, string(nn.ConstantName.(*ast.Identifier).Value))
}
-func (p *PrettyPrinter) printExprClone(n node.Node) {
- nn := n.(*expr.Clone)
+func (p *PrettyPrinter) printExprClone(n ast.Vertex) {
+ nn := n.(*ast.ExprClone)
io.WriteString(p.w, "clone ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprClosureUse(n node.Node) {
- nn := n.(*expr.ClosureUse)
+func (p *PrettyPrinter) printExprClosureUse(n ast.Vertex) {
+ nn := n.(*ast.ExprClosureUse)
io.WriteString(p.w, "use (")
p.joinPrint(", ", nn.Uses)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprClosure(n node.Node) {
- nn := n.(*expr.Closure)
+func (p *PrettyPrinter) printExprClosure(n ast.Vertex) {
+ nn := n.(*ast.ExprClosure)
if nn.Static {
io.WriteString(p.w, "static ")
@@ -1057,37 +1049,37 @@ func (p *PrettyPrinter) printExprClosure(n node.Node) {
io.WriteString(p.w, "}")
}
-func (p *PrettyPrinter) printExprConstFetch(n node.Node) {
- nn := n.(*expr.ConstFetch)
+func (p *PrettyPrinter) printExprConstFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprConstFetch)
- p.Print(nn.Constant)
+ p.Print(nn.Const)
}
-func (p *PrettyPrinter) printExprEmpty(n node.Node) {
- nn := n.(*expr.Empty)
+func (p *PrettyPrinter) printExprEmpty(n ast.Vertex) {
+ nn := n.(*ast.ExprEmpty)
io.WriteString(p.w, "empty(")
p.Print(nn.Expr)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprErrorSuppress(n node.Node) {
- nn := n.(*expr.ErrorSuppress)
+func (p *PrettyPrinter) printExprErrorSuppress(n ast.Vertex) {
+ nn := n.(*ast.ExprErrorSuppress)
io.WriteString(p.w, "@")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprEval(n node.Node) {
- nn := n.(*expr.Eval)
+func (p *PrettyPrinter) printExprEval(n ast.Vertex) {
+ nn := n.(*ast.ExprEval)
io.WriteString(p.w, "eval(")
p.Print(nn.Expr)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprExit(n node.Node) {
- nn := n.(*expr.Exit)
+func (p *PrettyPrinter) printExprExit(n ast.Vertex) {
+ nn := n.(*ast.ExprExit)
if nn.Die {
io.WriteString(p.w, "die(")
@@ -1098,8 +1090,8 @@ func (p *PrettyPrinter) printExprExit(n node.Node) {
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprFunctionCall(n node.Node) {
- nn := n.(*expr.FunctionCall)
+func (p *PrettyPrinter) printExprFunctionCall(n ast.Vertex) {
+ nn := n.(*ast.ExprFunctionCall)
p.Print(nn.Function)
io.WriteString(p.w, "(")
@@ -1107,48 +1099,48 @@ func (p *PrettyPrinter) printExprFunctionCall(n node.Node) {
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprInclude(n node.Node) {
- nn := n.(*expr.Include)
+func (p *PrettyPrinter) printExprInclude(n ast.Vertex) {
+ nn := n.(*ast.ExprInclude)
io.WriteString(p.w, "include ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprIncludeOnce(n node.Node) {
- nn := n.(*expr.IncludeOnce)
+func (p *PrettyPrinter) printExprIncludeOnce(n ast.Vertex) {
+ nn := n.(*ast.ExprIncludeOnce)
io.WriteString(p.w, "include_once ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprInstanceOf(n node.Node) {
- nn := n.(*expr.InstanceOf)
+func (p *PrettyPrinter) printExprInstanceOf(n ast.Vertex) {
+ nn := n.(*ast.ExprInstanceOf)
p.Print(nn.Expr)
io.WriteString(p.w, " instanceof ")
p.Print(nn.Class)
}
-func (p *PrettyPrinter) printExprIsset(n node.Node) {
- nn := n.(*expr.Isset)
+func (p *PrettyPrinter) printExprIsset(n ast.Vertex) {
+ nn := n.(*ast.ExprIsset)
io.WriteString(p.w, "isset(")
- p.joinPrint(", ", nn.Variables)
+ p.joinPrint(", ", nn.Vars)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprList(n node.Node) {
- nn := n.(*expr.List)
+func (p *PrettyPrinter) printExprList(n ast.Vertex) {
+ nn := n.(*ast.ExprList)
io.WriteString(p.w, "list(")
p.joinPrint(", ", nn.Items)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprMethodCall(n node.Node) {
- nn := n.(*expr.MethodCall)
+func (p *PrettyPrinter) printExprMethodCall(n ast.Vertex) {
+ nn := n.(*ast.ExprMethodCall)
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, "->")
p.Print(nn.Method)
io.WriteString(p.w, "(")
@@ -1156,8 +1148,8 @@ func (p *PrettyPrinter) printExprMethodCall(n node.Node) {
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprNew(n node.Node) {
- nn := n.(*expr.New)
+func (p *PrettyPrinter) printExprNew(n ast.Vertex) {
+ nn := n.(*ast.ExprNew)
io.WriteString(p.w, "new ")
p.Print(nn.Class)
@@ -1169,78 +1161,78 @@ func (p *PrettyPrinter) printExprNew(n node.Node) {
}
}
-func (p *PrettyPrinter) printExprPostDec(n node.Node) {
- nn := n.(*expr.PostDec)
+func (p *PrettyPrinter) printExprPostDec(n ast.Vertex) {
+ nn := n.(*ast.ExprPostDec)
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, "--")
}
-func (p *PrettyPrinter) printExprPostInc(n node.Node) {
- nn := n.(*expr.PostInc)
+func (p *PrettyPrinter) printExprPostInc(n ast.Vertex) {
+ nn := n.(*ast.ExprPostInc)
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, "++")
}
-func (p *PrettyPrinter) printExprPreDec(n node.Node) {
- nn := n.(*expr.PreDec)
+func (p *PrettyPrinter) printExprPreDec(n ast.Vertex) {
+ nn := n.(*ast.ExprPreDec)
io.WriteString(p.w, "--")
- p.Print(nn.Variable)
+ p.Print(nn.Var)
}
-func (p *PrettyPrinter) printExprPreInc(n node.Node) {
- nn := n.(*expr.PreInc)
+func (p *PrettyPrinter) printExprPreInc(n ast.Vertex) {
+ nn := n.(*ast.ExprPreInc)
io.WriteString(p.w, "++")
- p.Print(nn.Variable)
+ p.Print(nn.Var)
}
-func (p *PrettyPrinter) printExprPrint(n node.Node) {
- nn := n.(*expr.Print)
+func (p *PrettyPrinter) printExprPrint(n ast.Vertex) {
+ nn := n.(*ast.ExprPrint)
io.WriteString(p.w, "print(")
p.Print(nn.Expr)
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprPropertyFetch(n node.Node) {
- nn := n.(*expr.PropertyFetch)
+func (p *PrettyPrinter) printExprPropertyFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprPropertyFetch)
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, "->")
p.Print(nn.Property)
}
-func (p *PrettyPrinter) printExprReference(n node.Node) {
- nn := n.(*expr.Reference)
+func (p *PrettyPrinter) printExprReference(n ast.Vertex) {
+ nn := n.(*ast.ExprReference)
io.WriteString(p.w, "&")
- p.Print(nn.Variable)
+ p.Print(nn.Var)
}
-func (p *PrettyPrinter) printExprRequire(n node.Node) {
- nn := n.(*expr.Require)
+func (p *PrettyPrinter) printExprRequire(n ast.Vertex) {
+ nn := n.(*ast.ExprRequire)
io.WriteString(p.w, "require ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprRequireOnce(n node.Node) {
- nn := n.(*expr.RequireOnce)
+func (p *PrettyPrinter) printExprRequireOnce(n ast.Vertex) {
+ nn := n.(*ast.ExprRequireOnce)
io.WriteString(p.w, "require_once ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprShellExec(n node.Node) {
- nn := n.(*expr.ShellExec)
+func (p *PrettyPrinter) printExprShellExec(n ast.Vertex) {
+ nn := n.(*ast.ExprShellExec)
io.WriteString(p.w, "`")
for _, part := range nn.Parts {
switch part.(type) {
- case *scalar.EncapsedStringPart:
+ case *ast.ScalarEncapsedStringPart:
p.Print(part)
default:
io.WriteString(p.w, "{")
@@ -1251,24 +1243,24 @@ func (p *PrettyPrinter) printExprShellExec(n node.Node) {
io.WriteString(p.w, "`")
}
-func (p *PrettyPrinter) printExprShortArray(n node.Node) {
- nn := n.(*expr.ShortArray)
+func (p *PrettyPrinter) printExprShortArray(n ast.Vertex) {
+ nn := n.(*ast.ExprShortArray)
io.WriteString(p.w, "[")
p.joinPrint(", ", nn.Items)
io.WriteString(p.w, "]")
}
-func (p *PrettyPrinter) printExprShortList(n node.Node) {
- nn := n.(*expr.ShortList)
+func (p *PrettyPrinter) printExprShortList(n ast.Vertex) {
+ nn := n.(*ast.ExprShortList)
io.WriteString(p.w, "[")
p.joinPrint(", ", nn.Items)
io.WriteString(p.w, "]")
}
-func (p *PrettyPrinter) printExprStaticCall(n node.Node) {
- nn := n.(*expr.StaticCall)
+func (p *PrettyPrinter) printExprStaticCall(n ast.Vertex) {
+ nn := n.(*ast.ExprStaticCall)
p.Print(nn.Class)
io.WriteString(p.w, "::")
@@ -1278,16 +1270,16 @@ func (p *PrettyPrinter) printExprStaticCall(n node.Node) {
io.WriteString(p.w, ")")
}
-func (p *PrettyPrinter) printExprStaticPropertyFetch(n node.Node) {
- nn := n.(*expr.StaticPropertyFetch)
+func (p *PrettyPrinter) printExprStaticPropertyFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprStaticPropertyFetch)
p.Print(nn.Class)
io.WriteString(p.w, "::")
p.Print(nn.Property)
}
-func (p *PrettyPrinter) printExprTernary(n node.Node) {
- nn := n.(*expr.Ternary)
+func (p *PrettyPrinter) printExprTernary(n ast.Vertex) {
+ nn := n.(*ast.ExprTernary)
p.Print(nn.Condition)
io.WriteString(p.w, " ?")
@@ -1302,35 +1294,35 @@ func (p *PrettyPrinter) printExprTernary(n node.Node) {
p.Print(nn.IfFalse)
}
-func (p *PrettyPrinter) printExprUnaryMinus(n node.Node) {
- nn := n.(*expr.UnaryMinus)
+func (p *PrettyPrinter) printExprUnaryMinus(n ast.Vertex) {
+ nn := n.(*ast.ExprUnaryMinus)
io.WriteString(p.w, "-")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprUnaryPlus(n node.Node) {
- nn := n.(*expr.UnaryPlus)
+func (p *PrettyPrinter) printExprUnaryPlus(n ast.Vertex) {
+ nn := n.(*ast.ExprUnaryPlus)
io.WriteString(p.w, "+")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprVariable(n node.Node) {
- nn := n.(*expr.Variable)
+func (p *PrettyPrinter) printExprVariable(n ast.Vertex) {
+ nn := n.(*ast.ExprVariable)
io.WriteString(p.w, "$")
p.Print(nn.VarName)
}
-func (p *PrettyPrinter) printExprYieldFrom(n node.Node) {
- nn := n.(*expr.YieldFrom)
+func (p *PrettyPrinter) printExprYieldFrom(n ast.Vertex) {
+ nn := n.(*ast.ExprYieldFrom)
io.WriteString(p.w, "yield from ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printExprYield(n node.Node) {
- nn := n.(*expr.Yield)
+func (p *PrettyPrinter) printExprYield(n ast.Vertex) {
+ nn := n.(*ast.ExprYield)
io.WriteString(p.w, "yield ")
@@ -1344,32 +1336,32 @@ func (p *PrettyPrinter) printExprYield(n node.Node) {
// smtm
-func (p *PrettyPrinter) printStmtAltElseIf(n node.Node) {
- nn := n.(*stmt.AltElseIf)
+func (p *PrettyPrinter) printStmtAltElseIf(n ast.Vertex) {
+ nn := n.(*ast.StmtAltElseIf)
io.WriteString(p.w, "elseif (")
p.Print(nn.Cond)
io.WriteString(p.w, ") :")
- if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
+ if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
io.WriteString(p.w, "\n")
p.printNodes(s)
}
}
-func (p *PrettyPrinter) printStmtAltElse(n node.Node) {
- nn := n.(*stmt.AltElse)
+func (p *PrettyPrinter) printStmtAltElse(n ast.Vertex) {
+ nn := n.(*ast.StmtAltElse)
io.WriteString(p.w, "else :")
- if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
+ if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
io.WriteString(p.w, "\n")
p.printNodes(s)
}
}
-func (p *PrettyPrinter) printStmtAltFor(n node.Node) {
- nn := n.(*stmt.AltFor)
+func (p *PrettyPrinter) printStmtAltFor(n ast.Vertex) {
+ nn := n.(*ast.StmtAltFor)
io.WriteString(p.w, "for (")
p.joinPrint(", ", nn.Init)
@@ -1379,7 +1371,7 @@ func (p *PrettyPrinter) printStmtAltFor(n node.Node) {
p.joinPrint(", ", nn.Loop)
io.WriteString(p.w, ") :\n")
- s := nn.Stmt.(*stmt.StmtList)
+ s := nn.Stmt.(*ast.StmtStmtList)
p.printNodes(s.Stmts)
io.WriteString(p.w, "\n")
p.printIndent()
@@ -1387,8 +1379,8 @@ func (p *PrettyPrinter) printStmtAltFor(n node.Node) {
io.WriteString(p.w, "endfor;")
}
-func (p *PrettyPrinter) printStmtAltForeach(n node.Node) {
- nn := n.(*stmt.AltForeach)
+func (p *PrettyPrinter) printStmtAltForeach(n ast.Vertex) {
+ nn := n.(*ast.StmtAltForeach)
io.WriteString(p.w, "foreach (")
p.Print(nn.Expr)
@@ -1399,11 +1391,11 @@ func (p *PrettyPrinter) printStmtAltForeach(n node.Node) {
io.WriteString(p.w, " => ")
}
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, ") :\n")
- s := nn.Stmt.(*stmt.StmtList)
+ s := nn.Stmt.(*ast.StmtStmtList)
p.printNodes(s.Stmts)
io.WriteString(p.w, "\n")
@@ -1411,14 +1403,14 @@ func (p *PrettyPrinter) printStmtAltForeach(n node.Node) {
io.WriteString(p.w, "endforeach;")
}
-func (p *PrettyPrinter) printStmtAltIf(n node.Node) {
- nn := n.(*stmt.AltIf)
+func (p *PrettyPrinter) printStmtAltIf(n ast.Vertex) {
+ nn := n.(*ast.StmtAltIf)
io.WriteString(p.w, "if (")
p.Print(nn.Cond)
io.WriteString(p.w, ") :\n")
- s := nn.Stmt.(*stmt.StmtList)
+ s := nn.Stmt.(*ast.StmtStmtList)
p.printNodes(s.Stmts)
for _, elseif := range nn.ElseIf {
@@ -1438,8 +1430,8 @@ func (p *PrettyPrinter) printStmtAltIf(n node.Node) {
io.WriteString(p.w, "endif;")
}
-func (p *PrettyPrinter) printStmtAltSwitch(n node.Node) {
- nn := n.(*stmt.AltSwitch)
+func (p *PrettyPrinter) printStmtAltSwitch(n ast.Vertex) {
+ nn := n.(*ast.StmtAltSwitch)
io.WriteString(p.w, "switch (")
p.Print(nn.Cond)
@@ -1453,14 +1445,14 @@ func (p *PrettyPrinter) printStmtAltSwitch(n node.Node) {
io.WriteString(p.w, "endswitch;")
}
-func (p *PrettyPrinter) printStmtAltWhile(n node.Node) {
- nn := n.(*stmt.AltWhile)
+func (p *PrettyPrinter) printStmtAltWhile(n ast.Vertex) {
+ nn := n.(*ast.StmtAltWhile)
io.WriteString(p.w, "while (")
p.Print(nn.Cond)
io.WriteString(p.w, ") :\n")
- s := nn.Stmt.(*stmt.StmtList)
+ s := nn.Stmt.(*ast.StmtStmtList)
p.printNodes(s.Stmts)
io.WriteString(p.w, "\n")
@@ -1468,8 +1460,8 @@ func (p *PrettyPrinter) printStmtAltWhile(n node.Node) {
io.WriteString(p.w, "endwhile;")
}
-func (p *PrettyPrinter) printStmtBreak(n node.Node) {
- nn := n.(*stmt.Break)
+func (p *PrettyPrinter) printStmtBreak(n ast.Vertex) {
+ nn := n.(*ast.StmtBreak)
io.WriteString(p.w, "break")
if nn.Expr != nil {
@@ -1480,8 +1472,8 @@ func (p *PrettyPrinter) printStmtBreak(n node.Node) {
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtCase(n node.Node) {
- nn := n.(*stmt.Case)
+func (p *PrettyPrinter) printStmtCase(n ast.Vertex) {
+ nn := n.(*ast.StmtCase)
io.WriteString(p.w, "case ")
p.Print(nn.Cond)
@@ -1493,13 +1485,13 @@ func (p *PrettyPrinter) printStmtCase(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtCatch(n node.Node) {
- nn := n.(*stmt.Catch)
+func (p *PrettyPrinter) printStmtCatch(n ast.Vertex) {
+ nn := n.(*ast.StmtCatch)
io.WriteString(p.w, "catch (")
p.joinPrint(" | ", nn.Types)
io.WriteString(p.w, " ")
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, ") {\n")
p.printNodes(nn.Stmts)
io.WriteString(p.w, "\n")
@@ -1507,8 +1499,8 @@ func (p *PrettyPrinter) printStmtCatch(n node.Node) {
io.WriteString(p.w, "}")
}
-func (p *PrettyPrinter) printStmtClassMethod(n node.Node) {
- nn := n.(*stmt.ClassMethod)
+func (p *PrettyPrinter) printStmtClassMethod(n ast.Vertex) {
+ nn := n.(*ast.StmtClassMethod)
if nn.Modifiers != nil {
p.joinPrint(" ", nn.Modifiers)
@@ -1531,7 +1523,7 @@ func (p *PrettyPrinter) printStmtClassMethod(n node.Node) {
}
switch s := nn.Stmt.(type) {
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, "\n")
p.printIndent()
io.WriteString(p.w, "{\n")
@@ -1544,8 +1536,8 @@ func (p *PrettyPrinter) printStmtClassMethod(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtClass(n node.Node) {
- nn := n.(*stmt.Class)
+func (p *PrettyPrinter) printStmtClass(n ast.Vertex) {
+ nn := n.(*ast.StmtClass)
if nn.Modifiers != nil {
p.joinPrint(" ", nn.Modifiers)
@@ -1583,8 +1575,8 @@ func (p *PrettyPrinter) printStmtClass(n node.Node) {
io.WriteString(p.w, "}")
}
-func (p *PrettyPrinter) printStmtClassConstList(n node.Node) {
- nn := n.(*stmt.ClassConstList)
+func (p *PrettyPrinter) printStmtClassConstList(n ast.Vertex) {
+ nn := n.(*ast.StmtClassConstList)
if nn.Modifiers != nil {
p.joinPrint(" ", nn.Modifiers)
@@ -1597,16 +1589,16 @@ func (p *PrettyPrinter) printStmtClassConstList(n node.Node) {
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtConstant(n node.Node) {
- nn := n.(*stmt.Constant)
+func (p *PrettyPrinter) printStmtConstant(n ast.Vertex) {
+ nn := n.(*ast.StmtConstant)
p.Print(nn.ConstantName)
io.WriteString(p.w, " = ")
p.Print(nn.Expr)
}
-func (p *PrettyPrinter) printStmtContinue(n node.Node) {
- nn := n.(*stmt.Continue)
+func (p *PrettyPrinter) printStmtContinue(n ast.Vertex) {
+ nn := n.(*ast.StmtContinue)
io.WriteString(p.w, "continue")
if nn.Expr != nil {
@@ -1617,18 +1609,18 @@ func (p *PrettyPrinter) printStmtContinue(n node.Node) {
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtDeclare(n node.Node) {
- nn := n.(*stmt.Declare)
+func (p *PrettyPrinter) printStmtDeclare(n ast.Vertex) {
+ nn := n.(*ast.StmtDeclare)
io.WriteString(p.w, "declare(")
p.joinPrint(", ", nn.Consts)
io.WriteString(p.w, ")")
switch s := nn.Stmt.(type) {
- case *stmt.Nop:
+ case *ast.StmtNop:
p.Print(s)
break
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
default:
@@ -1640,8 +1632,8 @@ func (p *PrettyPrinter) printStmtDeclare(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtDefault(n node.Node) {
- nn := n.(*stmt.Default)
+func (p *PrettyPrinter) printStmtDefault(n ast.Vertex) {
+ nn := n.(*ast.StmtDefault)
io.WriteString(p.w, "default:")
if len(nn.Stmts) > 0 {
@@ -1650,12 +1642,12 @@ func (p *PrettyPrinter) printStmtDefault(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtDo(n node.Node) {
- nn := n.(*stmt.Do)
+func (p *PrettyPrinter) printStmtDo(n ast.Vertex) {
+ nn := n.(*ast.StmtDo)
io.WriteString(p.w, "do")
switch s := nn.Stmt.(type) {
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
io.WriteString(p.w, " ")
@@ -1674,25 +1666,25 @@ func (p *PrettyPrinter) printStmtDo(n node.Node) {
io.WriteString(p.w, ");")
}
-func (p *PrettyPrinter) printStmtEcho(n node.Node) {
- nn := n.(*stmt.Echo)
+func (p *PrettyPrinter) printStmtEcho(n ast.Vertex) {
+ nn := n.(*ast.StmtEcho)
io.WriteString(p.w, "echo ")
p.joinPrint(", ", nn.Exprs)
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtElseif(n node.Node) {
- nn := n.(*stmt.ElseIf)
+func (p *PrettyPrinter) printStmtElseif(n ast.Vertex) {
+ nn := n.(*ast.StmtElseIf)
io.WriteString(p.w, "elseif (")
p.Print(nn.Cond)
io.WriteString(p.w, ")")
switch s := nn.Stmt.(type) {
- case *stmt.Nop:
+ case *ast.StmtNop:
p.Print(s)
break
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
default:
@@ -1704,16 +1696,16 @@ func (p *PrettyPrinter) printStmtElseif(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtElse(n node.Node) {
- nn := n.(*stmt.Else)
+func (p *PrettyPrinter) printStmtElse(n ast.Vertex) {
+ nn := n.(*ast.StmtElse)
io.WriteString(p.w, "else")
switch s := nn.Stmt.(type) {
- case *stmt.Nop:
+ case *ast.StmtNop:
p.Print(s)
break
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
default:
@@ -1725,16 +1717,16 @@ func (p *PrettyPrinter) printStmtElse(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtExpression(n node.Node) {
- nn := n.(*stmt.Expression)
+func (p *PrettyPrinter) printStmtExpression(n ast.Vertex) {
+ nn := n.(*ast.StmtExpression)
p.Print(nn.Expr)
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtFinally(n node.Node) {
- nn := n.(*stmt.Finally)
+func (p *PrettyPrinter) printStmtFinally(n ast.Vertex) {
+ nn := n.(*ast.StmtFinally)
io.WriteString(p.w, "finally {\n")
p.printNodes(nn.Stmts)
@@ -1743,8 +1735,8 @@ func (p *PrettyPrinter) printStmtFinally(n node.Node) {
io.WriteString(p.w, "}")
}
-func (p *PrettyPrinter) printStmtFor(n node.Node) {
- nn := n.(*stmt.For)
+func (p *PrettyPrinter) printStmtFor(n ast.Vertex) {
+ nn := n.(*ast.StmtFor)
io.WriteString(p.w, "for (")
p.joinPrint(", ", nn.Init)
@@ -1755,10 +1747,10 @@ func (p *PrettyPrinter) printStmtFor(n node.Node) {
io.WriteString(p.w, ")")
switch s := nn.Stmt.(type) {
- case *stmt.Nop:
+ case *ast.StmtNop:
p.Print(s)
break
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
default:
@@ -1770,8 +1762,8 @@ func (p *PrettyPrinter) printStmtFor(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtForeach(n node.Node) {
- nn := n.(*stmt.Foreach)
+func (p *PrettyPrinter) printStmtForeach(n ast.Vertex) {
+ nn := n.(*ast.StmtForeach)
io.WriteString(p.w, "foreach (")
p.Print(nn.Expr)
@@ -1782,14 +1774,14 @@ func (p *PrettyPrinter) printStmtForeach(n node.Node) {
io.WriteString(p.w, " => ")
}
- p.Print(nn.Variable)
+ p.Print(nn.Var)
io.WriteString(p.w, ")")
switch s := nn.Stmt.(type) {
- case *stmt.Nop:
+ case *ast.StmtNop:
p.Print(s)
break
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
default:
@@ -1801,8 +1793,8 @@ func (p *PrettyPrinter) printStmtForeach(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtFunction(n node.Node) {
- nn := n.(*stmt.Function)
+func (p *PrettyPrinter) printStmtFunction(n ast.Vertex) {
+ nn := n.(*ast.StmtFunction)
io.WriteString(p.w, "function ")
@@ -1828,24 +1820,24 @@ func (p *PrettyPrinter) printStmtFunction(n node.Node) {
io.WriteString(p.w, "}")
}
-func (p *PrettyPrinter) printStmtGlobal(n node.Node) {
- nn := n.(*stmt.Global)
+func (p *PrettyPrinter) printStmtGlobal(n ast.Vertex) {
+ nn := n.(*ast.StmtGlobal)
io.WriteString(p.w, "global ")
p.joinPrint(", ", nn.Vars)
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtGoto(n node.Node) {
- nn := n.(*stmt.Goto)
+func (p *PrettyPrinter) printStmtGoto(n ast.Vertex) {
+ nn := n.(*ast.StmtGoto)
io.WriteString(p.w, "goto ")
p.Print(nn.Label)
io.WriteString(p.w, ";")
}
-func (p *PrettyPrinter) printStmtGroupUse(n node.Node) {
- nn := n.(*stmt.GroupUse)
+func (p *PrettyPrinter) printStmtGroupUse(n ast.Vertex) {
+ nn := n.(*ast.StmtGroupUse)
io.WriteString(p.w, "use ")
@@ -1860,22 +1852,22 @@ func (p *PrettyPrinter) printStmtGroupUse(n node.Node) {
io.WriteString(p.w, "};")
}
-func (p *PrettyPrinter) printStmtHaltCompiler(n node.Node) {
+func (p *PrettyPrinter) printStmtHaltCompiler(n ast.Vertex) {
io.WriteString(p.w, "__halt_compiler();")
}
-func (p *PrettyPrinter) printStmtIf(n node.Node) {
- nn := n.(*stmt.If)
+func (p *PrettyPrinter) printStmtIf(n ast.Vertex) {
+ nn := n.(*ast.StmtIf)
io.WriteString(p.w, "if (")
p.Print(nn.Cond)
io.WriteString(p.w, ")")
switch s := nn.Stmt.(type) {
- case *stmt.Nop:
+ case *ast.StmtNop:
p.Print(s)
break
- case *stmt.StmtList:
+ case *ast.StmtStmtList:
io.WriteString(p.w, " ")
p.Print(s)
default:
@@ -1900,16 +1892,16 @@ func (p *PrettyPrinter) printStmtIf(n node.Node) {
}
}
-func (p *PrettyPrinter) printStmtInlineHTML(n node.Node) {
- nn := n.(*stmt.InlineHtml)
+func (p *PrettyPrinter) printStmtInlineHTML(n ast.Vertex) {
+ nn := n.(*ast.StmtInlineHtml)
io.WriteString(p.w, "?>")
- io.WriteString(p.w, nn.Value)
+ io.WriteString(p.w, string(nn.Value))
io.WriteString(p.w, "HTML"},
- &stmt.Expression{
- Expr: &scalar.Heredoc{
- Label: "<<<\"LBL\"\n",
- Parts: []node.Node{
- &scalar.EncapsedStringPart{Value: "hello world\n"},
+ p.Print(&ast.Root{
+ Stmts: []ast.Vertex{
+ &ast.StmtInlineHtml{Value: []byte("HTML
")},
+ &ast.StmtExpression{
+ Expr: &ast.ScalarHeredoc{
+ Label: []byte("<<<\"LBL\"\n"),
+ Parts: []ast.Vertex{
+ &ast.ScalarEncapsedStringPart{Value: []byte("hello world\n")},
},
},
},
@@ -114,7 +107,7 @@ func TestPrintIdentifier(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&node.Identifier{Value: "test"})
+ p.Print(&ast.Identifier{Value: []byte("test")})
if o.String() != `test` {
t.Errorf("TestPrintIdentifier is failed\n")
@@ -125,12 +118,12 @@ func TestPrintParameter(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&node.Parameter{
+ p.Print(&ast.Parameter{
ByRef: false,
Variadic: true,
- VariableType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- DefaultValue: &scalar.String{Value: "'default'"},
+ Type: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ DefaultValue: &ast.ScalarString{Value: []byte("'default'")},
})
expected := "\\Foo ...$var = 'default'"
@@ -145,13 +138,13 @@ func TestPrintNullable(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&node.Nullable{
- Expr: &node.Parameter{
+ p.Print(&ast.Nullable{
+ Expr: &ast.Parameter{
ByRef: false,
Variadic: true,
- VariableType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- DefaultValue: &scalar.String{Value: "'default'"},
+ Type: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ DefaultValue: &ast.ScalarString{Value: []byte("'default'")},
},
})
@@ -167,10 +160,10 @@ func TestPrintArgument(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&node.Argument{
+ p.Print(&ast.Argument{
IsReference: false,
Variadic: true,
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := "...$var"
@@ -184,10 +177,10 @@ func TestPrintArgumentByRef(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&node.Argument{
+ p.Print(&ast.Argument{
IsReference: true,
Variadic: false,
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := "&$var"
@@ -204,8 +197,8 @@ func TestPrintNameNamePart(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&name.NamePart{
- Value: "foo",
+ p.Print(&ast.NameNamePart{
+ Value: []byte("foo"),
})
expected := "foo"
@@ -220,13 +213,13 @@ func TestPrintNameName(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&name.Name{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ p.Print(&ast.NameName{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
- &name.NamePart{
- Value: "Bar",
+ &ast.NameNamePart{
+ Value: []byte("Bar"),
},
},
})
@@ -243,13 +236,13 @@ func TestPrintNameFullyQualified(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&name.FullyQualified{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ p.Print(&ast.NameFullyQualified{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
- &name.NamePart{
- Value: "Bar",
+ &ast.NameNamePart{
+ Value: []byte("Bar"),
},
},
})
@@ -266,13 +259,13 @@ func TestPrintNameRelative(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&name.Relative{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ p.Print(&ast.NameRelative{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
- &name.NamePart{
- Value: "Bar",
+ &ast.NameNamePart{
+ Value: []byte("Bar"),
},
},
})
@@ -291,7 +284,7 @@ func TestPrintScalarLNumber(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&scalar.Lnumber{Value: "1"})
+ p.Print(&ast.ScalarLnumber{Value: []byte("1")})
if o.String() != `1` {
t.Errorf("TestPrintScalarLNumber is failed\n")
@@ -302,7 +295,7 @@ func TestPrintScalarDNumber(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&scalar.Dnumber{Value: ".1"})
+ p.Print(&ast.ScalarDnumber{Value: []byte(".1")})
if o.String() != `.1` {
t.Errorf("TestPrintScalarDNumber is failed\n")
@@ -313,7 +306,7 @@ func TestPrintScalarString(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&scalar.String{Value: "'hello world'"})
+ p.Print(&ast.ScalarString{Value: []byte("'hello world'")})
expected := `'hello world'`
actual := o.String()
@@ -327,7 +320,7 @@ func TestPrintScalarEncapsedStringPart(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&scalar.EncapsedStringPart{Value: "hello world"})
+ p.Print(&ast.ScalarEncapsedStringPart{Value: []byte("hello world")})
if o.String() != `hello world` {
t.Errorf("TestPrintScalarEncapsedStringPart is failed\n")
@@ -338,11 +331,11 @@ func TestPrintScalarEncapsed(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&scalar.Encapsed{
- Parts: []node.Node{
- &scalar.EncapsedStringPart{Value: "hello "},
- &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- &scalar.EncapsedStringPart{Value: " world"},
+ p.Print(&ast.ScalarEncapsed{
+ Parts: []ast.Vertex{
+ &ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ &ast.ScalarEncapsedStringPart{Value: []byte(" world")},
},
})
@@ -355,12 +348,12 @@ func TestPrintScalarHeredoc(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&scalar.Heredoc{
- Label: "<<>= $b`
@@ -652,9 +645,9 @@ func TestPrintBinaryBitwiseAnd(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.BitwiseAnd{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryBitwiseAnd{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a & $b`
@@ -669,9 +662,9 @@ func TestPrintBinaryBitwiseOr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.BitwiseOr{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryBitwiseOr{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a | $b`
@@ -686,9 +679,9 @@ func TestPrintBinaryBitwiseXor(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.BitwiseXor{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryBitwiseXor{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a ^ $b`
@@ -703,9 +696,9 @@ func TestPrintBinaryBooleanAnd(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.BooleanAnd{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryBooleanAnd{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a && $b`
@@ -720,9 +713,9 @@ func TestPrintBinaryBooleanOr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.BooleanOr{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryBooleanOr{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a || $b`
@@ -737,9 +730,9 @@ func TestPrintBinaryCoalesce(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Coalesce{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryCoalesce{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a ?? $b`
@@ -754,9 +747,9 @@ func TestPrintBinaryConcat(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Concat{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryConcat{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a . $b`
@@ -771,9 +764,9 @@ func TestPrintBinaryDiv(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Div{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryDiv{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a / $b`
@@ -788,9 +781,9 @@ func TestPrintBinaryEqual(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Equal{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryEqual{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a == $b`
@@ -805,9 +798,9 @@ func TestPrintBinaryGreaterOrEqual(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.GreaterOrEqual{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryGreaterOrEqual{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a >= $b`
@@ -822,9 +815,9 @@ func TestPrintBinaryGreater(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Greater{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryGreater{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a > $b`
@@ -839,9 +832,9 @@ func TestPrintBinaryIdentical(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Identical{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryIdentical{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a === $b`
@@ -856,9 +849,9 @@ func TestPrintBinaryLogicalAnd(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.LogicalAnd{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryLogicalAnd{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a and $b`
@@ -873,9 +866,9 @@ func TestPrintBinaryLogicalOr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.LogicalOr{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryLogicalOr{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a or $b`
@@ -890,9 +883,9 @@ func TestPrintBinaryLogicalXor(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.LogicalXor{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryLogicalXor{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a xor $b`
@@ -907,9 +900,9 @@ func TestPrintBinaryMinus(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Minus{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryMinus{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a - $b`
@@ -924,9 +917,9 @@ func TestPrintBinaryMod(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Mod{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryMod{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a % $b`
@@ -941,9 +934,9 @@ func TestPrintBinaryMul(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Mul{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryMul{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a * $b`
@@ -958,9 +951,9 @@ func TestPrintBinaryNotEqual(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.NotEqual{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryNotEqual{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a != $b`
@@ -975,9 +968,9 @@ func TestPrintBinaryNotIdentical(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.NotIdentical{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryNotIdentical{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a !== $b`
@@ -992,9 +985,9 @@ func TestPrintBinaryPlus(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Plus{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryPlus{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a + $b`
@@ -1009,9 +1002,9 @@ func TestPrintBinaryPow(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Pow{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryPow{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a ** $b`
@@ -1026,9 +1019,9 @@ func TestPrintBinaryShiftLeft(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.ShiftLeft{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryShiftLeft{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a << $b`
@@ -1043,9 +1036,9 @@ func TestPrintBinaryShiftRight(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.ShiftRight{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinaryShiftRight{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a >> $b`
@@ -1060,9 +1053,9 @@ func TestPrintBinarySmallerOrEqual(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.SmallerOrEqual{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinarySmallerOrEqual{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a <= $b`
@@ -1077,9 +1070,9 @@ func TestPrintBinarySmaller(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Smaller{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinarySmaller{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a < $b`
@@ -1094,9 +1087,9 @@ func TestPrintBinarySpaceship(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&binary.Spaceship{
- Left: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprBinarySpaceship{
+ Left: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Right: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a <=> $b`
@@ -1113,8 +1106,8 @@ func TestPrintArray(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.Array{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastArray{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(array)$var`
@@ -1129,8 +1122,8 @@ func TestPrintBool(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.Bool{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastBool{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(bool)$var`
@@ -1145,8 +1138,8 @@ func TestPrintDouble(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.Double{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastDouble{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(float)$var`
@@ -1161,8 +1154,8 @@ func TestPrintInt(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.Int{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastInt{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(int)$var`
@@ -1177,8 +1170,8 @@ func TestPrintObject(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.Object{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastObject{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(object)$var`
@@ -1193,8 +1186,8 @@ func TestPrintString(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.String{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastString{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(string)$var`
@@ -1209,8 +1202,8 @@ func TestPrintUnset(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&cast.Unset{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprCastUnset{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `(unset)$var`
@@ -1227,9 +1220,9 @@ func TestPrintExprArrayDimFetch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ArrayDimFetch{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- Dim: &scalar.Lnumber{Value: "1"},
+ p.Print(&ast.ExprArrayDimFetch{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ Dim: &ast.ScalarLnumber{Value: []byte("1")},
})
expected := `$var[1]`
@@ -1244,9 +1237,9 @@ func TestPrintExprArrayItemWithKey(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ArrayItem{
- Key: &scalar.String{Value: "'Hello'"},
- Val: &expr.Variable{VarName: &node.Identifier{Value: "world"}},
+ p.Print(&ast.ExprArrayItem{
+ Key: &ast.ScalarString{Value: []byte("'Hello'")},
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
})
expected := `'Hello' => $world`
@@ -1261,8 +1254,8 @@ func TestPrintExprArrayItem(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ArrayItem{
- Val: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "world"}}},
+ p.Print(&ast.ExprArrayItem{
+ Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}}},
})
expected := `&$world`
@@ -1277,18 +1270,18 @@ func TestPrintExprArray(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Array{
- Items: []node.Node{
- &expr.ArrayItem{
- Key: &scalar.String{Value: "'Hello'"},
- Val: &expr.Variable{VarName: &node.Identifier{Value: "world"}},
+ p.Print(&ast.ExprArray{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Key: &ast.ScalarString{Value: []byte("'Hello'")},
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
},
- &expr.ArrayItem{
- Key: &scalar.Lnumber{Value: "2"},
- Val: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}}},
+ &ast.ExprArrayItem{
+ Key: &ast.ScalarLnumber{Value: []byte("2")},
+ Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
},
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
},
},
})
@@ -1305,8 +1298,8 @@ func TestPrintExprBitwiseNot(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.BitwiseNot{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprBitwiseNot{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `~$var`
@@ -1321,8 +1314,8 @@ func TestPrintExprBooleanNot(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.BooleanNot{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprBooleanNot{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `!$var`
@@ -1337,9 +1330,9 @@ func TestPrintExprClassConstFetch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ClassConstFetch{
- Class: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- ConstantName: &node.Identifier{Value: "CONST"},
+ p.Print(&ast.ExprClassConstFetch{
+ Class: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ ConstantName: &ast.Identifier{Value: []byte("CONST")},
})
expected := `$var::CONST`
@@ -1354,8 +1347,8 @@ func TestPrintExprClone(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Clone{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprClone{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `clone $var`
@@ -1370,10 +1363,10 @@ func TestPrintExprClosureUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ClosureUse{
- Uses: []node.Node{
- &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}}},
- &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
+ p.Print(&ast.ExprClosureUse{
+ Uses: []ast.Vertex{
+ &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("bar")}},
},
})
@@ -1389,27 +1382,27 @@ func TestPrintExprClosure(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &expr.Closure{
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.ExprClosure{
Static: true,
ReturnsRef: true,
- Params: []node.Node{
- &node.Parameter{
+ Params: []ast.Vertex{
+ &ast.Parameter{
ByRef: true,
Variadic: false,
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
},
},
- ClosureUse: &expr.ClosureUse{
- Uses: []node.Node{
- &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ ClosureUse: &ast.ExprClosureUse{
+ Uses: []ast.Vertex{
+ &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
- ReturnType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ ReturnType: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
},
},
@@ -1431,8 +1424,8 @@ func TestPrintExprConstFetch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ConstFetch{
- Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}},
+ p.Print(&ast.ExprConstFetch{
+ Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}},
})
expected := "null"
@@ -1447,7 +1440,7 @@ func TestPrintEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Empty{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprEmpty{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `empty($var)`
actual := o.String()
@@ -1461,7 +1454,7 @@ func TestPrettyPrinterrorSuppress(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ErrorSuppress{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprErrorSuppress{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `@$var`
actual := o.String()
@@ -1475,7 +1468,7 @@ func TestPrintEval(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Eval{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprEval{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `eval($var)`
actual := o.String()
@@ -1489,7 +1482,7 @@ func TestPrintExit(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Exit{Die: false, Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprExit{Die: false, Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `exit($var)`
actual := o.String()
@@ -1503,7 +1496,7 @@ func TestPrintDie(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Exit{Die: true, Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprExit{Die: true, Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `die($var)`
actual := o.String()
@@ -1517,20 +1510,20 @@ func TestPrintFunctionCall(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.FunctionCall{
- Function: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
+ p.Print(&ast.ExprFunctionCall{
+ Function: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
IsReference: true,
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &node.Argument{
+ &ast.Argument{
Variadic: true,
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
},
},
},
@@ -1548,7 +1541,7 @@ func TestPrintInclude(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Include{Expr: &scalar.String{Value: "'path'"}})
+ p.Print(&ast.ExprInclude{Expr: &ast.ScalarString{Value: []byte("'path'")}})
expected := `include 'path'`
actual := o.String()
@@ -1562,7 +1555,7 @@ func TestPrintIncludeOnce(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.IncludeOnce{Expr: &scalar.String{Value: "'path'"}})
+ p.Print(&ast.ExprIncludeOnce{Expr: &ast.ScalarString{Value: []byte("'path'")}})
expected := `include_once 'path'`
actual := o.String()
@@ -1576,9 +1569,9 @@ func TestPrintInstanceOf(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.InstanceOf{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- Class: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
+ p.Print(&ast.ExprInstanceOf{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
})
expected := `$var instanceof Foo`
@@ -1593,10 +1586,10 @@ func TestPrintIsset(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Isset{
- Variables: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprIsset{
+ Vars: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
})
@@ -1612,19 +1605,19 @@ func TestPrintList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.List{
- Items: []node.Node{
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.ExprList{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &expr.ArrayItem{
- Val: &expr.List{
- Items: []node.Node{
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprList{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
},
},
},
@@ -1644,16 +1637,16 @@ func TestPrintMethodCall(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.MethodCall{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
- Method: &node.Identifier{Value: "bar"},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.ExprMethodCall{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+ Method: &ast.Identifier{Value: []byte("bar")},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
},
@@ -1671,15 +1664,15 @@ func TestPrintNew(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.New{
- Class: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.ExprNew{
+ Class: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
},
@@ -1697,8 +1690,8 @@ func TestPrintPostDec(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.PostDec{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprPostDec{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `$var--`
@@ -1713,8 +1706,8 @@ func TestPrintPostInc(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.PostInc{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprPostInc{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `$var++`
@@ -1729,8 +1722,8 @@ func TestPrintPreDec(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.PreDec{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprPreDec{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `--$var`
@@ -1745,8 +1738,8 @@ func TestPrintPreInc(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.PreInc{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprPreInc{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `++$var`
@@ -1761,7 +1754,7 @@ func TestPrintPrint(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Print{Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprPrint{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `print($var)`
actual := o.String()
@@ -1775,9 +1768,9 @@ func TestPrintPropertyFetch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.PropertyFetch{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
- Property: &node.Identifier{Value: "bar"},
+ p.Print(&ast.ExprPropertyFetch{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
+ Property: &ast.Identifier{Value: []byte("bar")},
})
expected := `$foo->bar`
@@ -1792,8 +1785,8 @@ func TestPrintExprReference(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Reference{
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
+ p.Print(&ast.ExprReference{
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
})
expected := `&$foo`
@@ -1808,7 +1801,7 @@ func TestPrintRequire(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Require{Expr: &scalar.String{Value: "'path'"}})
+ p.Print(&ast.ExprRequire{Expr: &ast.ScalarString{Value: []byte("'path'")}})
expected := `require 'path'`
actual := o.String()
@@ -1822,7 +1815,7 @@ func TestPrintRequireOnce(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.RequireOnce{Expr: &scalar.String{Value: "'path'"}})
+ p.Print(&ast.ExprRequireOnce{Expr: &ast.ScalarString{Value: []byte("'path'")}})
expected := `require_once 'path'`
actual := o.String()
@@ -1836,11 +1829,11 @@ func TestPrintShellExec(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ShellExec{
- Parts: []node.Node{
- &scalar.EncapsedStringPart{Value: "hello "},
- &expr.Variable{VarName: &node.Identifier{Value: "world"}},
- &scalar.EncapsedStringPart{Value: "!"},
+ p.Print(&ast.ExprShellExec{
+ Parts: []ast.Vertex{
+ &ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
+ &ast.ScalarEncapsedStringPart{Value: []byte("!")},
},
})
@@ -1856,18 +1849,18 @@ func TestPrintExprShortArray(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ShortArray{
- Items: []node.Node{
- &expr.ArrayItem{
- Key: &scalar.String{Value: "'Hello'"},
- Val: &expr.Variable{VarName: &node.Identifier{Value: "world"}},
+ p.Print(&ast.ExprShortArray{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Key: &ast.ScalarString{Value: []byte("'Hello'")},
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("world")}},
},
- &expr.ArrayItem{
- Key: &scalar.Lnumber{Value: "2"},
- Val: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}}},
+ &ast.ExprArrayItem{
+ Key: &ast.ScalarLnumber{Value: []byte("2")},
+ Val: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}},
},
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
},
},
})
@@ -1884,19 +1877,19 @@ func TestPrintShortList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.ShortList{
- Items: []node.Node{
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.ExprShortList{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &expr.ArrayItem{
- Val: &expr.List{
- Items: []node.Node{
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprList{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- &expr.ArrayItem{
- Val: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
},
},
},
@@ -1916,16 +1909,16 @@ func TestPrintStaticCall(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.StaticCall{
- Class: &node.Identifier{Value: "Foo"},
- Call: &node.Identifier{Value: "bar"},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.ExprStaticCall{
+ Class: &ast.Identifier{Value: []byte("Foo")},
+ Call: &ast.Identifier{Value: []byte("bar")},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
},
@@ -1943,9 +1936,9 @@ func TestPrintStaticPropertyFetch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.StaticPropertyFetch{
- Class: &node.Identifier{Value: "Foo"},
- Property: &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
+ p.Print(&ast.ExprStaticPropertyFetch{
+ Class: &ast.Identifier{Value: []byte("Foo")},
+ Property: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("bar")}},
})
expected := `Foo::$bar`
@@ -1960,9 +1953,9 @@ func TestPrintTernary(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Ternary{
- Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- IfFalse: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.ExprTernary{
+ Condition: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ IfFalse: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
})
expected := `$a ?: $b`
@@ -1977,10 +1970,10 @@ func TestPrintTernaryFull(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Ternary{
- Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- IfTrue: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
- IfFalse: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ p.Print(&ast.ExprTernary{
+ Condition: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ IfTrue: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
+ IfFalse: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
})
expected := `$a ? $b : $c`
@@ -1995,8 +1988,8 @@ func TestPrintUnaryMinus(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.UnaryMinus{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprUnaryMinus{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `-$var`
@@ -2011,8 +2004,8 @@ func TestPrintUnaryPlus(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.UnaryPlus{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprUnaryPlus{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `+$var`
@@ -2027,7 +2020,7 @@ func TestPrintVariable(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Variable{VarName: &expr.Variable{VarName: &node.Identifier{Value: "var"}}})
+ p.Print(&ast.ExprVariable{VarName: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}}})
expected := `$$var`
actual := o.String()
@@ -2041,8 +2034,8 @@ func TestPrintYieldFrom(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.YieldFrom{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprYieldFrom{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `yield from $var`
@@ -2057,8 +2050,8 @@ func TestPrintYield(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Yield{
- Value: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprYield{
+ Value: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `yield $var`
@@ -2073,9 +2066,9 @@ func TestPrintYieldFull(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&expr.Yield{
- Key: &expr.Variable{VarName: &node.Identifier{Value: "k"}},
- Value: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ p.Print(&ast.ExprYield{
+ Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
+ Value: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
})
expected := `yield $k => $var`
@@ -2092,11 +2085,11 @@ func TestPrintAltElseIf(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.AltElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+ p.Print(&ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
},
},
})
@@ -2114,9 +2107,9 @@ func TestPrintAltElseIfEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.AltElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.StmtList{},
+ p.Print(&ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtStmtList{},
})
expected := `elseif ($a) :`
@@ -2131,10 +2124,10 @@ func TestPrintAltElse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.AltElse{
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+ p.Print(&ast.StmtAltElse{
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
},
},
})
@@ -2152,8 +2145,8 @@ func TestPrintAltElseEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.AltElse{
- Stmt: &stmt.StmtList{},
+ p.Print(&ast.StmtAltElse{
+ Stmt: &ast.StmtStmtList{},
})
expected := `else :`
@@ -2168,21 +2161,21 @@ func TestPrintAltFor(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.AltFor{
- Init: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtAltFor{
+ Init: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- Cond: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ Cond: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- Loop: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ Loop: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
},
},
},
@@ -2205,15 +2198,15 @@ func TestPrintAltForeach(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.AltForeach{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- Key: &expr.Variable{VarName: &node.Identifier{Value: "key"}},
- Variable: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "val"}}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtAltForeach{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("key")}},
+ Var: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("val")}}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
},
},
},
@@ -2236,33 +2229,33 @@ func TestPrintAltIf(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.AltIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtAltIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}}},
},
},
- ElseIf: []node.Node{
- &stmt.AltElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+ ElseIf: []ast.Vertex{
+ &ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
},
},
},
- &stmt.AltElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
- Stmt: &stmt.StmtList{},
+ &ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
+ Stmt: &ast.StmtStmtList{},
},
},
- Else: &stmt.AltElse{
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+ Else: &ast.StmtAltElse{
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
},
},
},
@@ -2291,22 +2284,22 @@ func TestPrintStmtAltSwitch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.AltSwitch{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
- CaseList: &stmt.CaseList{
- Cases: []node.Node{
- &stmt.Case{
- Cond: &scalar.String{Value: "'a'"},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtAltSwitch{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
+ CaseList: &ast.StmtCaseList{
+ Cases: []ast.Vertex{
+ &ast.StmtCase{
+ Cond: &ast.ScalarString{Value: []byte("'a'")},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
},
- &stmt.Case{
- Cond: &scalar.String{Value: "'b'"},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+ &ast.StmtCase{
+ Cond: &ast.ScalarString{Value: []byte("'b'")},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
},
},
},
@@ -2334,13 +2327,13 @@ func TestPrintAltWhile(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.AltWhile{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtAltWhile{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}}},
},
},
},
@@ -2363,8 +2356,8 @@ func TestPrintStmtBreak(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Break{
- Expr: &scalar.Lnumber{Value: "1"},
+ p.Print(&ast.StmtBreak{
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
})
expected := "break 1;"
@@ -2379,10 +2372,10 @@ func TestPrintStmtCase(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Case{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ p.Print(&ast.StmtCase{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
})
@@ -2399,9 +2392,9 @@ func TestPrintStmtCaseEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Case{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmts: []node.Node{},
+ p.Print(&ast.StmtCase{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmts: []ast.Vertex{},
})
expected := "case $a:"
@@ -2416,16 +2409,16 @@ func TestPrintStmtCatch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Catch{
- Types: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
- &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtCatch{
+ Types: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+ &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
},
},
@@ -2447,26 +2440,26 @@ func TestPrintStmtClassMethod(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.ClassMethod{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
+ p.Print(&ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
ReturnsRef: true,
- MethodName: &node.Identifier{Value: "foo"},
- Params: []node.Node{
- &node.Parameter{
+ MethodName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{
+ &ast.Parameter{
ByRef: true,
- VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+ Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
},
- &node.Parameter{
+ &ast.Parameter{
Variadic: true,
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
- ReturnType: &name.Name{Parts: []node.Node{&name.NamePart{Value: "void"}}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ ReturnType: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
},
})
@@ -2485,24 +2478,24 @@ func TestPrintStmtAbstractClassMethod(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.ClassMethod{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
+ p.Print(&ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
ReturnsRef: true,
- MethodName: &node.Identifier{Value: "foo"},
- Params: []node.Node{
- &node.Parameter{
+ MethodName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{
+ &ast.Parameter{
ByRef: true,
- VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+ Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
},
- &node.Parameter{
+ &ast.Parameter{
Variadic: true,
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
- ReturnType: &name.Name{Parts: []node.Node{&name.NamePart{Value: "void"}}},
- Stmt: &stmt.Nop{},
+ ReturnType: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}}},
+ Stmt: &ast.StmtNop{},
})
expected := `public function &foo(?int &$a = null, ...$b): void;`
@@ -2517,27 +2510,27 @@ func TestPrintStmtClass(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Class{
- Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
- ClassName: &node.Identifier{Value: "Foo"},
- Extends: &stmt.ClassExtends{
- ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtClass{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+ ClassName: &ast.Identifier{Value: []byte("Foo")},
+ Extends: &ast.StmtClassExtends{
+ ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
},
- Implements: &stmt.ClassImplements{
- InterfaceNames: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+ Implements: &ast.StmtClassImplements{
+ InterfaceNames: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
- Stmts: []node.Node{
- &stmt.ClassConstList{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassConstList{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
},
@@ -2563,36 +2556,36 @@ func TestPrintStmtAnonymousClass(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Class{
- Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtClass{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- &node.Argument{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
},
- Extends: &stmt.ClassExtends{
- ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+ Extends: &ast.StmtClassExtends{
+ ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
},
- Implements: &stmt.ClassImplements{
- InterfaceNames: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+ Implements: &ast.StmtClassImplements{
+ InterfaceNames: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
- Stmts: []node.Node{
- &stmt.ClassConstList{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassConstList{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
},
@@ -2618,16 +2611,16 @@ func TestPrintStmtClassConstList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.ClassConstList{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'a'"},
+ p.Print(&ast.StmtClassConstList{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'a'")},
},
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "BAR"},
- Expr: &scalar.String{Value: "'b'"},
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("BAR")},
+ Expr: &ast.ScalarString{Value: []byte("'b'")},
},
},
})
@@ -2644,9 +2637,9 @@ func TestPrintStmtConstant(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'BAR'"},
+ p.Print(&ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'BAR'")},
})
expected := "FOO = 'BAR'"
@@ -2661,8 +2654,8 @@ func TestPrintStmtContinue(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Continue{
- Expr: &scalar.Lnumber{Value: "1"},
+ p.Print(&ast.StmtContinue{
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
})
expected := `continue 1;`
@@ -2677,18 +2670,18 @@ func TestPrintStmtDeclareStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Declare{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ p.Print(&ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtDeclare{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
},
@@ -2711,16 +2704,16 @@ func TestPrintStmtDeclareExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Declare{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ p.Print(&ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtDeclare{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
},
},
})
@@ -2740,14 +2733,14 @@ func TestPrintStmtDeclareNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Declare{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ p.Print(&ast.StmtDeclare{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
})
expected := `declare(FOO = 'bar');`
@@ -2762,9 +2755,9 @@ func TestPrintStmtDefalut(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Default{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ p.Print(&ast.StmtDefault{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
})
@@ -2781,8 +2774,8 @@ func TestPrintStmtDefalutEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Default{
- Stmts: []node.Node{},
+ p.Print(&ast.StmtDefault{
+ Stmts: []ast.Vertex{},
})
expected := `default:`
@@ -2797,12 +2790,12 @@ func TestPrintStmtDo_Expression(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Do{
- Cond: &scalar.Lnumber{Value: "1"},
- Stmt: &stmt.Expression{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtDo{
+ Cond: &ast.ScalarLnumber{Value: []byte("1")},
+ Stmt: &ast.StmtExpression{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
},
},
@@ -2824,13 +2817,13 @@ func TestPrintStmtDo_StmtList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Do{
- Cond: &scalar.Lnumber{Value: "1"},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtDo{
+ Cond: &ast.ScalarLnumber{Value: []byte("1")},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}},
},
},
},
@@ -2853,10 +2846,10 @@ func TestPrintStmtEcho(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Echo{
- Exprs: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.StmtEcho{
+ Exprs: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
})
@@ -2872,11 +2865,11 @@ func TestPrintStmtElseIfStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.ElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ p.Print(&ast.StmtElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -2895,9 +2888,9 @@ func TestPrintStmtElseIfExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.ElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ p.Print(&ast.StmtElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
})
expected := `elseif ($a)
@@ -2913,9 +2906,9 @@ func TestPrintStmtElseIfNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.ElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.Nop{},
+ p.Print(&ast.StmtElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtNop{},
})
expected := `elseif ($a);`
@@ -2930,10 +2923,10 @@ func TestPrintStmtElseStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Else{
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ p.Print(&ast.StmtElse{
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -2952,8 +2945,8 @@ func TestPrintStmtElseExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Else{
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ p.Print(&ast.StmtElse{
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
})
expected := `else
@@ -2969,8 +2962,8 @@ func TestPrintStmtElseNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Else{
- Stmt: &stmt.Nop{},
+ p.Print(&ast.StmtElse{
+ Stmt: &ast.StmtNop{},
})
expected := `else;`
@@ -2985,7 +2978,7 @@ func TestPrintExpression(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Expression{Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}})
+ p.Print(&ast.StmtExpression{Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}}})
expected := `$a;`
actual := o.String()
@@ -2999,11 +2992,11 @@ func TestPrintStmtFinally(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Finally{
- Stmts: []node.Node{
- &stmt.Nop{},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtFinally{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
},
@@ -3025,24 +3018,24 @@ func TestPrintStmtForStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.For{
- Init: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtFor{
+ Init: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- Cond: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "c"}},
- &expr.Variable{VarName: &node.Identifier{Value: "d"}},
+ Cond: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}},
},
- Loop: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "e"}},
- &expr.Variable{VarName: &node.Identifier{Value: "f"}},
+ Loop: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("f")}},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
},
@@ -3065,19 +3058,19 @@ func TestPrintStmtForExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.For{
- Init: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtFor{
+ Init: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- Cond: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ Cond: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- Loop: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ Loop: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
},
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
},
},
})
@@ -3097,17 +3090,17 @@ func TestPrintStmtForNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.For{
- Init: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+ p.Print(&ast.StmtFor{
+ Init: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
},
- Cond: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ Cond: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- Loop: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+ Loop: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
})
expected := `for ($a; $b; $c);`
@@ -3122,14 +3115,14 @@ func TestPrintStmtForeachStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Foreach{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtForeach{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
},
@@ -3152,13 +3145,13 @@ func TestPrintStmtForeachExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Foreach{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Key: &expr.Variable{VarName: &node.Identifier{Value: "k"}},
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "v"}},
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtForeach{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("v")}},
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
},
},
})
@@ -3178,11 +3171,11 @@ func TestPrintStmtForeachNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Foreach{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Key: &expr.Variable{VarName: &node.Identifier{Value: "k"}},
- Variable: &expr.Reference{Variable: &expr.Variable{VarName: &node.Identifier{Value: "v"}}},
- Stmt: &stmt.Nop{},
+ p.Print(&ast.StmtForeach{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Key: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("k")}},
+ Var: &ast.ExprReference{Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("v")}}},
+ Stmt: &ast.StmtNop{},
})
expected := `foreach ($a as $k => &$v);`
@@ -3197,21 +3190,21 @@ func TestPrintStmtFunction(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.Function{
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtFunction{
ReturnsRef: true,
- FunctionName: &node.Identifier{Value: "foo"},
- Params: []node.Node{
- &node.Parameter{
+ FunctionName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{
+ &ast.Parameter{
ByRef: true,
Variadic: false,
- Variable: &expr.Variable{VarName: &node.Identifier{Value: "var"}},
+ Var: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("var")}},
},
},
- ReturnType: &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Stmts: []node.Node{
- &stmt.Nop{},
+ ReturnType: &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
},
@@ -3233,10 +3226,10 @@ func TestPrintStmtGlobal(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Global{
- Vars: []node.Node{
- &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.StmtGlobal{
+ Vars: []ast.Vertex{
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
})
@@ -3252,8 +3245,8 @@ func TestPrintStmtGoto(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Goto{
- Label: &node.Identifier{Value: "FOO"},
+ p.Print(&ast.StmtGoto{
+ Label: &ast.Identifier{Value: []byte("FOO")},
})
expected := `goto FOO;`
@@ -3268,16 +3261,16 @@ func TestPrintStmtGroupUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.GroupUse{
- UseType: &node.Identifier{Value: "function"},
- Prefix: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- UseList: []node.Node{
- &stmt.Use{
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
- Alias: &node.Identifier{Value: "Baz"},
+ p.Print(&ast.StmtGroupUse{
+ UseType: &ast.Identifier{Value: []byte("function")},
+ Prefix: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ UseList: []ast.Vertex{
+ &ast.StmtUse{
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+ Alias: &ast.Identifier{Value: []byte("Baz")},
},
- &stmt.Use{
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+ &ast.StmtUse{
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
})
@@ -3294,7 +3287,7 @@ func TestPrintHaltCompiler(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.HaltCompiler{})
+ p.Print(&ast.StmtHaltCompiler{})
expected := `__halt_compiler();`
actual := o.String()
@@ -3308,32 +3301,32 @@ func TestPrintIfExpression(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.If{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.Expression{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtExpression{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
- ElseIf: []node.Node{
- &stmt.ElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "d"}},
+ ElseIf: []ast.Vertex{
+ &ast.StmtElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("c")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("d")}},
},
},
},
},
- &stmt.ElseIf{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
- Stmt: &stmt.Nop{},
+ &ast.StmtElseIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("e")}},
+ Stmt: &ast.StmtNop{},
},
},
- Else: &stmt.Else{
- Stmt: &stmt.Expression{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "f"}},
+ Else: &ast.StmtElse{
+ Stmt: &ast.StmtExpression{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("f")}},
},
},
},
@@ -3361,14 +3354,14 @@ func TestPrintIfStmtList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.Namespace{
- Stmts: []node.Node{
- &stmt.If{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{
- Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+ p.Print(&ast.StmtNamespace{
+ Stmts: []ast.Vertex{
+ &ast.StmtIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{
+ Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("b")}},
},
},
},
@@ -3392,9 +3385,9 @@ func TestPrintIfNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.If{
- Cond: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
- Stmt: &stmt.Nop{},
+ p.Print(&ast.StmtIf{
+ Cond: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("a")}},
+ Stmt: &ast.StmtNop{},
})
expected := `if ($a);`
@@ -3409,8 +3402,8 @@ func TestPrintInlineHtml(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
- p.Print(&stmt.InlineHtml{
- Value: "test",
+ p.Print(&ast.StmtInlineHtml{
+ Value: []byte("test"),
})
expected := `?>test 0 {
+ io.WriteString(p.w, glue)
+ }
+
+ p.Print(n)
+ }
+}
+
+func (p *Printer) printNodes(nn []ast.Vertex) {
+ for _, n := range nn {
+ p.Print(n)
+ }
+}
+
+func (p *Printer) printFreeFloating(n ast.Vertex, pos token.Position) {
+ if n == nil {
+ return
+ }
+
+ for _, m := range n.GetNode().Tokens[pos] {
+ io.WriteString(p.w, string(m.Value))
+ }
+}
+
+func (p *Printer) printNode(n ast.Vertex) {
+ switch n.(type) {
+
+ // node
+
+ case *ast.Root:
+ p.printNodeRoot(n)
+ case *ast.Identifier:
+ p.printNodeIdentifier(n)
+ case *ast.Parameter:
+ p.printNodeParameter(n)
+ case *ast.Nullable:
+ p.printNodeNullable(n)
+ case *ast.Argument:
+ p.printNodeArgument(n)
+
+ // name
+
+ case *ast.NameNamePart:
+ p.printNameNamePart(n)
+ case *ast.NameName:
+ p.printNameName(n)
+ case *ast.NameFullyQualified:
+ p.printNameFullyQualified(n)
+ case *ast.NameRelative:
+ p.printNameRelative(n)
+
+ // scalar
+
+ case *ast.ScalarLnumber:
+ p.printScalarLNumber(n)
+ case *ast.ScalarDnumber:
+ p.printScalarDNumber(n)
+ case *ast.ScalarString:
+ p.printScalarString(n)
+ case *ast.ScalarEncapsedStringPart:
+ p.printScalarEncapsedStringPart(n)
+ case *ast.ScalarEncapsed:
+ p.printScalarEncapsed(n)
+ case *ast.ScalarHeredoc:
+ p.printScalarHeredoc(n)
+ case *ast.ScalarMagicConstant:
+ p.printScalarMagicConstant(n)
+
+ // assign
+
+ case *ast.ExprAssign:
+ p.printAssign(n)
+ case *ast.ExprAssignReference:
+ p.printAssignReference(n)
+ case *ast.ExprAssignBitwiseAnd:
+ p.printAssignBitwiseAnd(n)
+ case *ast.ExprAssignBitwiseOr:
+ p.printAssignBitwiseOr(n)
+ case *ast.ExprAssignBitwiseXor:
+ p.printAssignBitwiseXor(n)
+ case *ast.ExprAssignCoalesce:
+ p.printAssignCoalesce(n)
+ case *ast.ExprAssignConcat:
+ p.printAssignConcat(n)
+ case *ast.ExprAssignDiv:
+ p.printAssignDiv(n)
+ case *ast.ExprAssignMinus:
+ p.printAssignMinus(n)
+ case *ast.ExprAssignMod:
+ p.printAssignMod(n)
+ case *ast.ExprAssignMul:
+ p.printAssignMul(n)
+ case *ast.ExprAssignPlus:
+ p.printAssignPlus(n)
+ case *ast.ExprAssignPow:
+ p.printAssignPow(n)
+ case *ast.ExprAssignShiftLeft:
+ p.printAssignShiftLeft(n)
+ case *ast.ExprAssignShiftRight:
+ p.printAssignShiftRight(n)
+
+ // binary
+
+ case *ast.ExprBinaryBitwiseAnd:
+ p.printBinaryBitwiseAnd(n)
+ case *ast.ExprBinaryBitwiseOr:
+ p.printBinaryBitwiseOr(n)
+ case *ast.ExprBinaryBitwiseXor:
+ p.printBinaryBitwiseXor(n)
+ case *ast.ExprBinaryBooleanAnd:
+ p.printBinaryBooleanAnd(n)
+ case *ast.ExprBinaryBooleanOr:
+ p.printBinaryBooleanOr(n)
+ case *ast.ExprBinaryCoalesce:
+ p.printBinaryCoalesce(n)
+ case *ast.ExprBinaryConcat:
+ p.printBinaryConcat(n)
+ case *ast.ExprBinaryDiv:
+ p.printBinaryDiv(n)
+ case *ast.ExprBinaryEqual:
+ p.printBinaryEqual(n)
+ case *ast.ExprBinaryGreaterOrEqual:
+ p.printBinaryGreaterOrEqual(n)
+ case *ast.ExprBinaryGreater:
+ p.printBinaryGreater(n)
+ case *ast.ExprBinaryIdentical:
+ p.printBinaryIdentical(n)
+ case *ast.ExprBinaryLogicalAnd:
+ p.printBinaryLogicalAnd(n)
+ case *ast.ExprBinaryLogicalOr:
+ p.printBinaryLogicalOr(n)
+ case *ast.ExprBinaryLogicalXor:
+ p.printBinaryLogicalXor(n)
+ case *ast.ExprBinaryMinus:
+ p.printBinaryMinus(n)
+ case *ast.ExprBinaryMod:
+ p.printBinaryMod(n)
+ case *ast.ExprBinaryMul:
+ p.printBinaryMul(n)
+ case *ast.ExprBinaryNotEqual:
+ p.printBinaryNotEqual(n)
+ case *ast.ExprBinaryNotIdentical:
+ p.printBinaryNotIdentical(n)
+ case *ast.ExprBinaryPlus:
+ p.printBinaryPlus(n)
+ case *ast.ExprBinaryPow:
+ p.printBinaryPow(n)
+ case *ast.ExprBinaryShiftLeft:
+ p.printBinaryShiftLeft(n)
+ case *ast.ExprBinaryShiftRight:
+ p.printBinaryShiftRight(n)
+ case *ast.ExprBinarySmallerOrEqual:
+ p.printBinarySmallerOrEqual(n)
+ case *ast.ExprBinarySmaller:
+ p.printBinarySmaller(n)
+ case *ast.ExprBinarySpaceship:
+ p.printBinarySpaceship(n)
+
+ // cast
+
+ case *ast.ExprCastArray:
+ p.printArray(n)
+ case *ast.ExprCastBool:
+ p.printBool(n)
+ case *ast.ExprCastDouble:
+ p.printDouble(n)
+ case *ast.ExprCastInt:
+ p.printInt(n)
+ case *ast.ExprCastObject:
+ p.printObject(n)
+ case *ast.ExprCastString:
+ p.printString(n)
+ case *ast.ExprCastUnset:
+ p.printUnset(n)
+
+ // expr
+
+ case *ast.ExprArrayDimFetch:
+ p.printExprArrayDimFetch(n)
+ case *ast.ExprArrayItem:
+ p.printExprArrayItem(n)
+ case *ast.ExprArray:
+ p.printExprArray(n)
+ case *ast.ExprArrowFunction:
+ p.printExprArrowFunction(n)
+ case *ast.ExprBitwiseNot:
+ p.printExprBitwiseNot(n)
+ case *ast.ExprBooleanNot:
+ p.printExprBooleanNot(n)
+ case *ast.ExprClassConstFetch:
+ p.printExprClassConstFetch(n)
+ case *ast.ExprClone:
+ p.printExprClone(n)
+ case *ast.ExprClosureUse:
+ p.printExprClosureUse(n)
+ case *ast.ExprClosure:
+ p.printExprClosure(n)
+ case *ast.ExprConstFetch:
+ p.printExprConstFetch(n)
+ case *ast.ExprEmpty:
+ p.printExprEmpty(n)
+ case *ast.ExprErrorSuppress:
+ p.printExprErrorSuppress(n)
+ case *ast.ExprEval:
+ p.printExprEval(n)
+ case *ast.ExprExit:
+ p.printExprExit(n)
+ case *ast.ExprFunctionCall:
+ p.printExprFunctionCall(n)
+ case *ast.ExprInclude:
+ p.printExprInclude(n)
+ case *ast.ExprIncludeOnce:
+ p.printExprIncludeOnce(n)
+ case *ast.ExprInstanceOf:
+ p.printExprInstanceOf(n)
+ case *ast.ExprIsset:
+ p.printExprIsset(n)
+ case *ast.ExprList:
+ p.printExprList(n)
+ case *ast.ExprMethodCall:
+ p.printExprMethodCall(n)
+ case *ast.ExprNew:
+ p.printExprNew(n)
+ case *ast.ExprPostDec:
+ p.printExprPostDec(n)
+ case *ast.ExprPostInc:
+ p.printExprPostInc(n)
+ case *ast.ExprPreDec:
+ p.printExprPreDec(n)
+ case *ast.ExprPreInc:
+ p.printExprPreInc(n)
+ case *ast.ExprPrint:
+ p.printExprPrint(n)
+ case *ast.ExprPropertyFetch:
+ p.printExprPropertyFetch(n)
+ case *ast.ExprReference:
+ p.printExprReference(n)
+ case *ast.ExprRequire:
+ p.printExprRequire(n)
+ case *ast.ExprRequireOnce:
+ p.printExprRequireOnce(n)
+ case *ast.ExprShellExec:
+ p.printExprShellExec(n)
+ case *ast.ExprShortArray:
+ p.printExprShortArray(n)
+ case *ast.ExprShortList:
+ p.printExprShortList(n)
+ case *ast.ExprStaticCall:
+ p.printExprStaticCall(n)
+ case *ast.ExprStaticPropertyFetch:
+ p.printExprStaticPropertyFetch(n)
+ case *ast.ExprTernary:
+ p.printExprTernary(n)
+ case *ast.ExprUnaryMinus:
+ p.printExprUnaryMinus(n)
+ case *ast.ExprUnaryPlus:
+ p.printExprUnaryPlus(n)
+ case *ast.ExprVariable:
+ p.printExprVariable(n)
+ case *ast.ExprYieldFrom:
+ p.printExprYieldFrom(n)
+ case *ast.ExprYield:
+ p.printExprYield(n)
+
+ // stmt
+
+ case *ast.StmtAltElseIf:
+ p.printStmtAltElseIf(n)
+ case *ast.StmtAltElse:
+ p.printStmtAltElse(n)
+ case *ast.StmtAltFor:
+ p.printStmtAltFor(n)
+ case *ast.StmtAltForeach:
+ p.printStmtAltForeach(n)
+ case *ast.StmtAltIf:
+ p.printStmtAltIf(n)
+ case *ast.StmtAltSwitch:
+ p.printStmtAltSwitch(n)
+ case *ast.StmtAltWhile:
+ p.printStmtAltWhile(n)
+ case *ast.StmtBreak:
+ p.printStmtBreak(n)
+ case *ast.StmtCase:
+ p.printStmtCase(n)
+ case *ast.StmtCatch:
+ p.printStmtCatch(n)
+ case *ast.StmtClassMethod:
+ p.printStmtClassMethod(n)
+ case *ast.StmtClass:
+ p.printStmtClass(n)
+ case *ast.StmtClassConstList:
+ p.printStmtClassConstList(n)
+ case *ast.StmtConstList:
+ p.printStmtConstList(n)
+ case *ast.StmtConstant:
+ p.printStmtConstant(n)
+ case *ast.StmtContinue:
+ p.printStmtContinue(n)
+ case *ast.StmtDeclare:
+ p.printStmtDeclare(n)
+ case *ast.StmtDefault:
+ p.printStmtDefault(n)
+ case *ast.StmtDo:
+ p.printStmtDo(n)
+ case *ast.StmtEcho:
+ p.printStmtEcho(n)
+ case *ast.StmtElseIf:
+ p.printStmtElseif(n)
+ case *ast.StmtElse:
+ p.printStmtElse(n)
+ case *ast.StmtExpression:
+ p.printStmtExpression(n)
+ case *ast.StmtFinally:
+ p.printStmtFinally(n)
+ case *ast.StmtFor:
+ p.printStmtFor(n)
+ case *ast.StmtForeach:
+ p.printStmtForeach(n)
+ case *ast.StmtFunction:
+ p.printStmtFunction(n)
+ case *ast.StmtGlobal:
+ p.printStmtGlobal(n)
+ case *ast.StmtGoto:
+ p.printStmtGoto(n)
+ case *ast.StmtGroupUse:
+ p.printStmtGroupUse(n)
+ case *ast.StmtHaltCompiler:
+ p.printStmtHaltCompiler(n)
+ case *ast.StmtIf:
+ p.printStmtIf(n)
+ case *ast.StmtInlineHtml:
+ p.printStmtInlineHTML(n)
+ case *ast.StmtInterface:
+ p.printStmtInterface(n)
+ case *ast.StmtLabel:
+ p.printStmtLabel(n)
+ case *ast.StmtNamespace:
+ p.printStmtNamespace(n)
+ case *ast.StmtNop:
+ p.printStmtNop(n)
+ case *ast.StmtPropertyList:
+ p.printStmtPropertyList(n)
+ case *ast.StmtProperty:
+ p.printStmtProperty(n)
+ case *ast.StmtReturn:
+ p.printStmtReturn(n)
+ case *ast.StmtStaticVar:
+ p.printStmtStaticVar(n)
+ case *ast.StmtStatic:
+ p.printStmtStatic(n)
+ case *ast.StmtStmtList:
+ p.printStmtStmtList(n)
+ case *ast.StmtSwitch:
+ p.printStmtSwitch(n)
+ case *ast.StmtThrow:
+ p.printStmtThrow(n)
+ case *ast.StmtTraitAdaptationList:
+ p.printStmtTraitAdaptationList(n)
+ case *ast.StmtTraitMethodRef:
+ p.printStmtTraitMethodRef(n)
+ case *ast.StmtTraitUseAlias:
+ p.printStmtTraitUseAlias(n)
+ case *ast.StmtTraitUsePrecedence:
+ p.printStmtTraitUsePrecedence(n)
+ case *ast.StmtTraitUse:
+ p.printStmtTraitUse(n)
+ case *ast.StmtTrait:
+ p.printStmtTrait(n)
+ case *ast.StmtTry:
+ p.printStmtTry(n)
+ case *ast.StmtUnset:
+ p.printStmtUnset(n)
+ case *ast.StmtUseList:
+ p.printStmtUseList(n)
+ case *ast.StmtUse:
+ p.printStmtUse(n)
+ case *ast.StmtWhile:
+ p.printStmtWhile(n)
+ }
+}
+
+// node
+
+func (p *Printer) printNodeRoot(n ast.Vertex) {
+ nn := n.(*ast.Root)
+ p.SetState(HtmlState)
+ p.printFreeFloating(nn, token.Start)
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeIdentifier(n ast.Vertex) {
+ nn := n.(*ast.Identifier)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, string(nn.Value))
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeParameter(n ast.Vertex) {
+ nn := n.(*ast.Parameter)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Type != nil {
+ p.Print(nn.Type)
+ }
+ p.printFreeFloating(nn, token.OptionalType)
+
+ if nn.ByRef {
+ io.WriteString(p.w, "&")
+ }
+ p.printFreeFloating(nn, token.Ampersand)
+
+ if nn.Variadic {
+ io.WriteString(p.w, "...")
+ }
+ p.printFreeFloating(nn, token.Variadic)
+
+ p.Print(nn.Var)
+
+ if nn.DefaultValue != nil {
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "=")
+ p.Print(nn.DefaultValue)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeNullable(n ast.Vertex) {
+ nn := n.(*ast.Nullable)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "?")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNodeArgument(n ast.Vertex) {
+ nn := n.(*ast.Argument)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.IsReference {
+ io.WriteString(p.w, "&")
+ }
+ p.printFreeFloating(nn, token.Ampersand)
+
+ if nn.Variadic {
+ io.WriteString(p.w, "...")
+ }
+ p.printFreeFloating(nn, token.Variadic)
+
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+// name
+
+func (p *Printer) printNameNamePart(n ast.Vertex) {
+ nn := n.(*ast.NameNamePart)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, string(nn.Value))
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNameName(n ast.Vertex) {
+ nn := n.(*ast.NameName)
+ p.printFreeFloating(nn, token.Start)
+
+ p.joinPrint("\\", nn.Parts)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNameFullyQualified(n ast.Vertex) {
+ nn := n.(*ast.NameFullyQualified)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "\\")
+ p.joinPrint("\\", nn.Parts)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printNameRelative(n ast.Vertex) {
+ nn := n.(*ast.NameRelative)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "namespace")
+ p.printFreeFloating(nn, token.Namespace)
+
+ for _, part := range nn.Parts {
+ io.WriteString(p.w, "\\")
+ p.Print(part)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+// scalar
+
+func (p *Printer) printScalarLNumber(n ast.Vertex) {
+ nn := n.(*ast.ScalarLnumber)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, string(nn.Value))
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarDNumber(n ast.Vertex) {
+ nn := n.(*ast.ScalarDnumber)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, string(nn.Value))
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarString(n ast.Vertex) {
+ nn := n.(*ast.ScalarString)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, string(nn.Value))
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarEncapsedStringPart(n ast.Vertex) {
+ nn := n.(*ast.ScalarEncapsedStringPart)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, string(nn.Value))
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarEncapsed(n ast.Vertex) {
+ nn := n.(*ast.ScalarEncapsed)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "\"")
+ for _, part := range nn.Parts {
+ switch part.(type) {
+ case *ast.ExprArrayDimFetch:
+ s := part.GetNode().Tokens[token.Start]
+ if len(s) > 0 && string(s[0].Value) == "${" {
+ p.printExprArrayDimFetchWithoutLeadingDollar(part)
+ } else {
+ p.Print(part)
+ }
+ case *ast.ExprVariable:
+ s := part.GetNode().Tokens[token.Start]
+ if len(s) > 0 && string(s[0].Value) == "${" {
+ p.printExprVariableWithoutLeadingDollar(part)
+ } else {
+ p.Print(part)
+ }
+ default:
+ p.Print(part)
+ }
+ }
+ io.WriteString(p.w, "\"")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarHeredoc(n ast.Vertex) {
+ nn := n.(*ast.ScalarHeredoc)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, string(nn.Label))
+
+ for _, part := range nn.Parts {
+ switch part.(type) {
+ case *ast.ExprArrayDimFetch:
+ s := part.GetNode().Tokens[token.Start]
+ if len(s) > 0 && string(s[0].Value) == "${" {
+ p.printExprArrayDimFetchWithoutLeadingDollar(part)
+ } else {
+ p.Print(part)
+ }
+ case *ast.ExprVariable:
+ s := part.GetNode().Tokens[token.Start]
+ if len(s) > 0 && string(s[0].Value) == "${" {
+ p.printExprVariableWithoutLeadingDollar(part)
+ } else {
+ p.Print(part)
+ }
+ default:
+ p.Print(part)
+ }
+ }
+
+ io.WriteString(p.w, strings.Trim(string(nn.Label), "<\"'\n"))
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printScalarMagicConstant(n ast.Vertex) {
+ nn := n.(*ast.ScalarMagicConstant)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, string(nn.Value))
+ p.printFreeFloating(nn, token.End)
+}
+
+// Assign
+
+func (p *Printer) printAssign(n ast.Vertex) {
+ nn := n.(*ast.ExprAssign)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignReference(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignReference)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "=")
+ p.printFreeFloating(nn, token.Equal)
+ io.WriteString(p.w, "&")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignBitwiseAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignBitwiseAnd)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "&")
+ io.WriteString(p.w, "=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignBitwiseOr(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignBitwiseOr)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "|=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignBitwiseXor(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignBitwiseXor)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "^=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignCoalesce(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignCoalesce)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "??=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignConcat(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignConcat)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, ".=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignDiv(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignDiv)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "/=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignMinus(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignMinus)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "-=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignMod(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignMod)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "%=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignMul(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignMul)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "*=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignPlus(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignPlus)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "+=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignPow(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignPow)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "**=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignShiftLeft(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignShiftLeft)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "<<=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printAssignShiftRight(n ast.Vertex) {
+ nn := n.(*ast.ExprAssignShiftRight)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, ">>=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+// binary
+
+func (p *Printer) printBinaryBitwiseAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBitwiseAnd)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "&")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBitwiseOr(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBitwiseOr)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "|")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBitwiseXor(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBitwiseXor)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "^")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBooleanAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBooleanAnd)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "&&")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryBooleanOr(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryBooleanOr)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "||")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryCoalesce(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryCoalesce)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "??")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryConcat(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryConcat)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ".")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryDiv(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryDiv)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "/")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryEqual)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "==")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryGreaterOrEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryGreaterOrEqual)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ">=")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryGreater(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryGreater)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ">")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryIdentical(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryIdentical)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "===")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryLogicalAnd(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryLogicalAnd)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "and")
+ if nn.Right.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryLogicalOr(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryLogicalOr)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "or")
+ if nn.Right.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryLogicalXor(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryLogicalXor)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "xor")
+ if nn.Right.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryMinus(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryMinus)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "-")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryMod(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryMod)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "%")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryMul(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryMul)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "*")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryNotEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryNotEqual)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ p.printFreeFloating(nn, token.Equal)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "!=")
+ }
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryNotIdentical(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryNotIdentical)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "!==")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryPlus(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryPlus)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "+")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryPow(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryPow)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "**")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryShiftLeft(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryShiftLeft)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "<<")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinaryShiftRight(n ast.Vertex) {
+ nn := n.(*ast.ExprBinaryShiftRight)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ">>")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinarySmallerOrEqual(n ast.Vertex) {
+ nn := n.(*ast.ExprBinarySmallerOrEqual)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "<=")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinarySmaller(n ast.Vertex) {
+ nn := n.(*ast.ExprBinarySmaller)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "<")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBinarySpaceship(n ast.Vertex) {
+ nn := n.(*ast.ExprBinarySpaceship)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Left)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "<=>")
+ p.Print(nn.Right)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+// cast
+
+func (p *Printer) printArray(n ast.Vertex) {
+ nn := n.(*ast.ExprCastArray)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(array)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printBool(n ast.Vertex) {
+ nn := n.(*ast.ExprCastBool)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(boolean)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printDouble(n ast.Vertex) {
+ nn := n.(*ast.ExprCastDouble)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(float)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printInt(n ast.Vertex) {
+ nn := n.(*ast.ExprCastInt)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(integer)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printObject(n ast.Vertex) {
+ nn := n.(*ast.ExprCastObject)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(object)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printString(n ast.Vertex) {
+ nn := n.(*ast.ExprCastString)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(string)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printUnset(n ast.Vertex) {
+ nn := n.(*ast.ExprCastUnset)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Cast)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "(unset)")
+ }
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+// expr
+
+func (p *Printer) printExprArrayDimFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprArrayDimFetch)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "[")
+ }
+ p.Print(nn.Dim)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "]")
+ }
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArrayDimFetchWithoutLeadingDollar(n ast.Vertex) {
+ nn := n.(*ast.ExprArrayDimFetch)
+ p.printFreeFloating(nn, token.Start)
+ p.printExprVariableWithoutLeadingDollar(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "[")
+ }
+ p.Print(nn.Dim)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "]")
+ }
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArrayItem(n ast.Vertex) {
+ nn := n.(*ast.ExprArrayItem)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Unpack {
+ io.WriteString(p.w, "...")
+ }
+
+ if nn.Key != nil {
+ p.Print(nn.Key)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "=>")
+ }
+
+ p.Print(nn.Val)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArray(n ast.Vertex) {
+ nn := n.(*ast.ExprArray)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "array")
+ p.printFreeFloating(nn, token.Array)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Items)
+ p.printFreeFloating(nn, token.ArrayPairList)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprArrowFunction(n ast.Vertex) {
+ nn := n.(*ast.ExprArrowFunction)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Static {
+ io.WriteString(p.w, "static")
+ }
+ p.printFreeFloating(nn, token.Static)
+ if nn.Static && n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ io.WriteString(p.w, "fn")
+ p.printFreeFloating(nn, token.Function)
+
+ if nn.ReturnsRef {
+ io.WriteString(p.w, "&")
+ }
+ p.printFreeFloating(nn, token.Ampersand)
+
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Params)
+ p.printFreeFloating(nn, token.ParameterList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Params)
+
+ if nn.ReturnType != nil {
+ io.WriteString(p.w, ":")
+ p.Print(nn.ReturnType)
+ }
+ p.printFreeFloating(nn, token.ReturnType)
+
+ io.WriteString(p.w, "=>")
+
+ p.printNode(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprBitwiseNot(n ast.Vertex) {
+ nn := n.(*ast.ExprBitwiseNot)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "~")
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprBooleanNot(n ast.Vertex) {
+ nn := n.(*ast.ExprBooleanNot)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "!")
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClassConstFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprClassConstFetch)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Class)
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "::")
+ p.Print(nn.ConstantName)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClone(n ast.Vertex) {
+ nn := n.(*ast.ExprClone)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "clone")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClosureUse(n ast.Vertex) {
+ nn := n.(*ast.ExprClosureUse)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "use")
+ p.printFreeFloating(nn, token.Use)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Uses)
+ p.printFreeFloating(nn, token.LexicalVarList)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprClosure(n ast.Vertex) {
+ nn := n.(*ast.ExprClosure)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Static {
+ io.WriteString(p.w, "static")
+ }
+ p.printFreeFloating(nn, token.Static)
+ if nn.Static && n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ io.WriteString(p.w, "function")
+ p.printFreeFloating(nn, token.Function)
+
+ if nn.ReturnsRef {
+ io.WriteString(p.w, "&")
+ }
+ p.printFreeFloating(nn, token.Ampersand)
+
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Params)
+ p.printFreeFloating(nn, token.ParameterList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Params)
+
+ if nn.ClosureUse != nil {
+ p.Print(nn.ClosureUse)
+ }
+ p.printFreeFloating(nn, token.LexicalVars)
+
+ if nn.ReturnType != nil {
+ io.WriteString(p.w, ":")
+ p.Print(nn.ReturnType)
+ }
+ p.printFreeFloating(nn, token.ReturnType)
+
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprConstFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprConstFetch)
+ p.printFreeFloating(nn, token.Start)
+ p.Print(nn.Const)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprEmpty(n ast.Vertex) {
+ nn := n.(*ast.ExprEmpty)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "empty")
+ p.printFreeFloating(nn, token.Empty)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprErrorSuppress(n ast.Vertex) {
+ nn := n.(*ast.ExprErrorSuppress)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "@")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprEval(n ast.Vertex) {
+ nn := n.(*ast.ExprEval)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "eval")
+ p.printFreeFloating(nn, token.Eval)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprExit(n ast.Vertex) {
+ nn := n.(*ast.ExprExit)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Die {
+ io.WriteString(p.w, "die")
+ } else {
+ io.WriteString(p.w, "exit")
+ }
+ p.printFreeFloating(nn, token.Exit)
+
+ if nn.Expr != nil && nn.Expr.GetNode().Tokens.IsEmpty() && nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprFunctionCall(n ast.Vertex) {
+ nn := n.(*ast.ExprFunctionCall)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Function)
+
+ p.printFreeFloating(nn.ArgumentList, token.Start)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.ArgumentList.Arguments)
+ p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn.ArgumentList, token.End)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprInclude(n ast.Vertex) {
+ nn := n.(*ast.ExprInclude)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "include")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprIncludeOnce(n ast.Vertex) {
+ nn := n.(*ast.ExprIncludeOnce)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "include_once")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprInstanceOf(n ast.Vertex) {
+ nn := n.(*ast.ExprInstanceOf)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ io.WriteString(p.w, "instanceof")
+
+ if nn.Class.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Class)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprIsset(n ast.Vertex) {
+ nn := n.(*ast.ExprIsset)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "isset")
+ p.printFreeFloating(nn, token.Isset)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Vars)
+ p.printFreeFloating(nn, token.VarList)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprList(n ast.Vertex) {
+ nn := n.(*ast.ExprList)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "list")
+ p.printFreeFloating(nn, token.List)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Items)
+ p.printFreeFloating(nn, token.ArrayPairList)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprMethodCall(n ast.Vertex) {
+ nn := n.(*ast.ExprMethodCall)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "->")
+ p.Print(nn.Method)
+
+ p.printFreeFloating(nn.ArgumentList, token.Start)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.ArgumentList.Arguments)
+ p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn.ArgumentList, token.End)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprNew(n ast.Vertex) {
+ nn := n.(*ast.ExprNew)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "new")
+ if nn.Class.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Class)
+
+ if nn.ArgumentList != nil {
+ p.printFreeFloating(nn.ArgumentList, token.Start)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.ArgumentList.Arguments)
+ p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn.ArgumentList, token.End)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPostDec(n ast.Vertex) {
+ nn := n.(*ast.ExprPostDec)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "--")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPostInc(n ast.Vertex) {
+ nn := n.(*ast.ExprPostInc)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "++")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPreDec(n ast.Vertex) {
+ nn := n.(*ast.ExprPreDec)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "--")
+ p.Print(nn.Var)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPreInc(n ast.Vertex) {
+ nn := n.(*ast.ExprPreInc)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "++")
+ p.Print(nn.Var)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPrint(n ast.Vertex) {
+ nn := n.(*ast.ExprPrint)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "print")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprPropertyFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprPropertyFetch)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "->")
+ p.Print(nn.Property)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprReference(n ast.Vertex) {
+ nn := n.(*ast.ExprReference)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "&")
+ p.Print(nn.Var)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprRequire(n ast.Vertex) {
+ nn := n.(*ast.ExprRequire)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "require")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprRequireOnce(n ast.Vertex) {
+ nn := n.(*ast.ExprRequireOnce)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "require_once")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprShellExec(n ast.Vertex) {
+ nn := n.(*ast.ExprShellExec)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "`")
+ p.joinPrint("", nn.Parts)
+ io.WriteString(p.w, "`")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprShortArray(n ast.Vertex) {
+ nn := n.(*ast.ExprShortArray)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "[")
+ p.joinPrint(",", nn.Items)
+ p.printFreeFloating(nn, token.ArrayPairList)
+ io.WriteString(p.w, "]")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprShortList(n ast.Vertex) {
+ nn := n.(*ast.ExprShortList)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "[")
+ p.joinPrint(",", nn.Items)
+ p.printFreeFloating(nn, token.ArrayPairList)
+ io.WriteString(p.w, "]")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprStaticCall(n ast.Vertex) {
+ nn := n.(*ast.ExprStaticCall)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Class)
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "::")
+ p.Print(nn.Call)
+
+ p.printFreeFloating(nn.ArgumentList, token.Start)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.ArgumentList.Arguments)
+ p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn.ArgumentList, token.End)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprStaticPropertyFetch(n ast.Vertex) {
+ nn := n.(*ast.ExprStaticPropertyFetch)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Class)
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "::")
+ p.Print(nn.Property)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprTernary(n ast.Vertex) {
+ nn := n.(*ast.ExprTernary)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Condition)
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, "?")
+
+ if nn.IfTrue != nil {
+ p.Print(nn.IfTrue)
+ }
+ p.printFreeFloating(nn, token.True)
+
+ io.WriteString(p.w, ":")
+ p.Print(nn.IfFalse)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprUnaryMinus(n ast.Vertex) {
+ nn := n.(*ast.ExprUnaryMinus)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "-")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprUnaryPlus(n ast.Vertex) {
+ nn := n.(*ast.ExprUnaryPlus)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "+")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprVariable(n ast.Vertex) {
+ nn := n.(*ast.ExprVariable)
+ p.printFreeFloating(nn, token.Start)
+
+ p.printFreeFloating(nn, token.Dollar)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "$")
+ }
+
+ p.Print(nn.VarName)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprVariableWithoutLeadingDollar(n ast.Vertex) {
+ nn := n.(*ast.ExprVariable)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.VarName)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprYieldFrom(n ast.Vertex) {
+ nn := n.(*ast.ExprYieldFrom)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "yield from")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printExprYield(n ast.Vertex) {
+ nn := n.(*ast.ExprYield)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "yield")
+
+ if nn.Key != nil {
+ if nn.Key.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Key)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, "=>")
+ } else {
+ if nn.Value.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.Print(nn.Value)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+// smtm
+
+func (p *Printer) printStmtAltElseIf(n ast.Vertex) {
+ nn := n.(*ast.StmtAltElseIf)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "elseif")
+ p.printFreeFloating(nn, token.ElseIf)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, ":")
+
+ if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
+ p.printNodes(s)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltElse(n ast.Vertex) {
+ nn := n.(*ast.StmtAltElse)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "else")
+ p.printFreeFloating(nn, token.Else)
+ io.WriteString(p.w, ":")
+
+ if s := nn.Stmt.(*ast.StmtStmtList).Stmts; len(s) > 0 {
+ p.printNodes(s)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltFor(n ast.Vertex) {
+ nn := n.(*ast.StmtAltFor)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "for")
+ p.printFreeFloating(nn, token.For)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Init)
+ p.printFreeFloating(nn, token.InitExpr)
+ io.WriteString(p.w, ";")
+ p.joinPrint(",", nn.Cond)
+ p.printFreeFloating(nn, token.CondExpr)
+ io.WriteString(p.w, ";")
+ p.joinPrint(",", nn.Loop)
+ p.printFreeFloating(nn, token.IncExpr)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, ":")
+
+ s := nn.Stmt.(*ast.StmtStmtList)
+ p.printNodes(s.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+
+ io.WriteString(p.w, "endfor")
+ p.printFreeFloating(nn, token.AltEnd)
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltForeach(n ast.Vertex) {
+ nn := n.(*ast.StmtAltForeach)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "foreach")
+ p.printFreeFloating(nn, token.Foreach)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "as")
+
+ if nn.Key != nil {
+ if nn.Key.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Key)
+ p.printFreeFloating(nn, token.Key)
+ io.WriteString(p.w, "=>")
+ } else {
+ if nn.Var.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+
+ io.WriteString(p.w, ":")
+ s := nn.Stmt.(*ast.StmtStmtList)
+ p.printNodes(s.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+
+ io.WriteString(p.w, "endforeach")
+ p.printFreeFloating(nn, token.AltEnd)
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltIf(n ast.Vertex) {
+ nn := n.(*ast.StmtAltIf)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "if")
+ p.printFreeFloating(nn, token.If)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, ":")
+
+ s := nn.Stmt.(*ast.StmtStmtList)
+ p.printNodes(s.Stmts)
+
+ for _, elseif := range nn.ElseIf {
+ p.Print(elseif)
+ }
+
+ if nn.Else != nil {
+ p.Print(nn.Else)
+ }
+
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "endif")
+ p.printFreeFloating(nn, token.AltEnd)
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltSwitch(n ast.Vertex) {
+ nn := n.(*ast.StmtAltSwitch)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "switch")
+ p.printFreeFloating(nn, token.Switch)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, ":")
+
+ p.printFreeFloating(nn.CaseList, token.Start)
+ p.printFreeFloating(nn.CaseList, token.CaseListStart)
+ p.printNodes(nn.CaseList.Cases)
+ p.printFreeFloating(nn.CaseList, token.CaseListEnd)
+ p.printFreeFloating(nn.CaseList, token.End)
+
+ io.WriteString(p.w, "endswitch")
+ p.printFreeFloating(nn, token.AltEnd)
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtAltWhile(n ast.Vertex) {
+ nn := n.(*ast.StmtAltWhile)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "while")
+ p.printFreeFloating(nn, token.While)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, ":")
+
+ s := nn.Stmt.(*ast.StmtStmtList)
+ p.printNodes(s.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+
+ io.WriteString(p.w, "endwhile")
+ p.printFreeFloating(nn, token.AltEnd)
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtBreak(n ast.Vertex) {
+ nn := n.(*ast.StmtBreak)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "break")
+ if nn.Expr != nil {
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ }
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtCase(n ast.Vertex) {
+ nn := n.(*ast.StmtCase)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "case")
+ if nn.Cond.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ p.printFreeFloating(nn, token.CaseSeparator)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ":")
+ }
+
+ if len(nn.Stmts) > 0 {
+ p.printNodes(nn.Stmts)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtCatch(n ast.Vertex) {
+ nn := n.(*ast.StmtCatch)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "catch")
+ p.printFreeFloating(nn, token.Catch)
+ io.WriteString(p.w, "(")
+ p.joinPrint("|", nn.Types)
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtClassMethod(n ast.Vertex) {
+ nn := n.(*ast.StmtClassMethod)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Modifiers != nil {
+ for k, m := range nn.Modifiers {
+ if k > 0 && m.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(m)
+ }
+
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+ p.printFreeFloating(nn, token.ModifierList)
+ io.WriteString(p.w, "function")
+ p.printFreeFloating(nn, token.Function)
+
+ if nn.ReturnsRef {
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "&")
+ p.printFreeFloating(nn, token.Ampersand)
+ } else {
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.Print(nn.MethodName)
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Params)
+ p.printFreeFloating(nn, token.ParameterList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Params)
+
+ if nn.ReturnType != nil {
+ io.WriteString(p.w, ":")
+ p.Print(nn.ReturnType)
+ }
+
+ p.Print(nn.Stmt)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtClass(n ast.Vertex) {
+ nn := n.(*ast.StmtClass)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Modifiers != nil {
+ for k, m := range nn.Modifiers {
+ if k > 0 && m.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(m)
+ }
+
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+ p.printFreeFloating(nn, token.ModifierList)
+ io.WriteString(p.w, "class")
+ p.printFreeFloating(nn, token.Class)
+
+ if nn.ClassName != nil {
+ if nn.ClassName.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.ClassName)
+ }
+
+ if nn.ArgumentList != nil {
+ p.printFreeFloating(nn.ArgumentList, token.Start)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.ArgumentList.Arguments)
+ p.printFreeFloating(nn.ArgumentList, token.ArgumentList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn.ArgumentList, token.End)
+ }
+
+ if nn.Extends != nil {
+ p.printFreeFloating(nn.Extends, token.Start)
+ if nn.Extends.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "extends")
+ if nn.Extends.ClassName.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Extends.ClassName)
+ }
+
+ if nn.Implements != nil {
+ p.printFreeFloating(nn.Implements, token.Start)
+ if nn.Implements.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "implements")
+ if nn.Implements.InterfaceNames[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Implements.InterfaceNames)
+ }
+
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtClassConstList(n ast.Vertex) {
+ nn := n.(*ast.StmtClassConstList)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Modifiers != nil {
+ for k, m := range nn.Modifiers {
+ if k > 0 && m.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(m)
+ }
+
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+ p.printFreeFloating(nn, token.ModifierList)
+ io.WriteString(p.w, "const")
+
+ if nn.Consts[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Consts)
+ p.printFreeFloating(nn, token.ConstList)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtConstList(n ast.Vertex) {
+ nn := n.(*ast.StmtConstList)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "const")
+
+ if nn.Consts[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Consts)
+ p.printFreeFloating(nn, token.Stmts)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtConstant(n ast.Vertex) {
+ nn := n.(*ast.StmtConstant)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.ConstantName)
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "=")
+ p.Print(nn.Expr)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtContinue(n ast.Vertex) {
+ nn := n.(*ast.StmtContinue)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "continue")
+
+ if nn.Expr != nil {
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ }
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtDeclare(n ast.Vertex) {
+ nn := n.(*ast.StmtDeclare)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "declare")
+ p.printFreeFloating(nn, token.Declare)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Consts)
+ p.printFreeFloating(nn, token.ConstList)
+ io.WriteString(p.w, ")")
+
+ if nn.Alt {
+ p.printFreeFloating(nn, token.Cond)
+ io.WriteString(p.w, ":")
+
+ s := nn.Stmt.(*ast.StmtStmtList)
+ p.printNodes(s.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+
+ io.WriteString(p.w, "enddeclare")
+ p.printFreeFloating(nn, token.AltEnd)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+ } else {
+ p.Print(nn.Stmt)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtDefault(n ast.Vertex) {
+ nn := n.(*ast.StmtDefault)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "default")
+ p.printFreeFloating(nn, token.Default)
+ p.printFreeFloating(nn, token.CaseSeparator)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ":")
+ }
+
+ if len(nn.Stmts) > 0 {
+ p.printNodes(nn.Stmts)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtDo(n ast.Vertex) {
+ nn := n.(*ast.StmtDo)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "do")
+
+ if _, ok := nn.Stmt.(*ast.StmtStmtList); !ok {
+ if nn.Stmt.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.Print(nn.Stmt)
+ p.printFreeFloating(nn, token.Stmts)
+
+ io.WriteString(p.w, "while")
+ p.printFreeFloating(nn, token.While)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Cond)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtEcho(n ast.Vertex) {
+ nn := n.(*ast.StmtEcho)
+
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "echo")
+ }
+ if nn.Exprs[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ p.printFreeFloating(nn, token.Start)
+ p.printFreeFloating(nn, token.Echo)
+
+ p.joinPrint(",", nn.Exprs)
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtElseif(n ast.Vertex) {
+ nn := n.(*ast.StmtElseIf)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "elseif")
+ p.printFreeFloating(nn, token.ElseIf)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+
+ p.Print(nn.Stmt)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtElse(n ast.Vertex) {
+ nn := n.(*ast.StmtElse)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "else")
+
+ if _, ok := nn.Stmt.(*ast.StmtStmtList); !ok {
+ if nn.Stmt.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.Print(nn.Stmt)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtExpression(n ast.Vertex) {
+ nn := n.(*ast.StmtExpression)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtFinally(n ast.Vertex) {
+ nn := n.(*ast.StmtFinally)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "finally")
+ p.printFreeFloating(nn, token.Finally)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtFor(n ast.Vertex) {
+ nn := n.(*ast.StmtFor)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "for")
+ p.printFreeFloating(nn, token.For)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Init)
+ p.printFreeFloating(nn, token.InitExpr)
+ io.WriteString(p.w, ";")
+ p.joinPrint(",", nn.Cond)
+ p.printFreeFloating(nn, token.CondExpr)
+ io.WriteString(p.w, ";")
+ p.joinPrint(",", nn.Loop)
+ p.printFreeFloating(nn, token.IncExpr)
+ io.WriteString(p.w, ")")
+
+ p.Print(nn.Stmt)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtForeach(n ast.Vertex) {
+ nn := n.(*ast.StmtForeach)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "foreach")
+ p.printFreeFloating(nn, token.Foreach)
+ io.WriteString(p.w, "(")
+
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ io.WriteString(p.w, "as")
+
+ if nn.Key != nil {
+ if nn.Key.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Key)
+ p.printFreeFloating(nn, token.Key)
+ io.WriteString(p.w, "=>")
+ } else {
+ if nn.Var.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+ p.Print(nn.Var)
+ p.printFreeFloating(nn, token.Var)
+
+ io.WriteString(p.w, ")")
+
+ p.Print(nn.Stmt)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtFunction(n ast.Vertex) {
+ nn := n.(*ast.StmtFunction)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "function")
+ p.printFreeFloating(nn, token.Function)
+
+ if nn.ReturnsRef {
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "&")
+ } else {
+ if nn.FunctionName.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.Print(nn.FunctionName)
+ p.printFreeFloating(nn, token.Name)
+
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Params)
+ p.printFreeFloating(nn, token.ParamList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.Params)
+
+ if nn.ReturnType != nil {
+ io.WriteString(p.w, ":")
+ p.Print(nn.ReturnType)
+ }
+ p.printFreeFloating(nn, token.ReturnType)
+
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtGlobal(n ast.Vertex) {
+ nn := n.(*ast.StmtGlobal)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "global")
+ p.joinPrint(",", nn.Vars)
+ p.printFreeFloating(nn, token.VarList)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtGoto(n ast.Vertex) {
+ nn := n.(*ast.StmtGoto)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "goto")
+ if nn.Label.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Label)
+ p.printFreeFloating(nn, token.Label)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtGroupUse(n ast.Vertex) {
+ nn := n.(*ast.StmtGroupUse)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "use")
+ p.printFreeFloating(nn, token.Use)
+
+ if nn.UseType != nil {
+ if nn.UseType.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.UseType)
+ }
+
+ if nn.Prefix.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Prefix)
+ io.WriteString(p.w, "\\")
+ p.printFreeFloating(nn, token.Slash)
+
+ io.WriteString(p.w, "{")
+ p.joinPrint(",", nn.UseList)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+ p.printFreeFloating(nn, token.UseDeclarationList)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtHaltCompiler(n ast.Vertex) {
+ nn := n.(*ast.StmtHaltCompiler)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "__halt_compiler")
+ p.printFreeFloating(nn, token.HaltCompiller)
+ io.WriteString(p.w, "(")
+ p.printFreeFloating(nn, token.OpenParenthesisToken)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.CloseParenthesisToken)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtIf(n ast.Vertex) {
+ nn := n.(*ast.StmtIf)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "if")
+ p.printFreeFloating(n, token.If)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(n, token.Expr)
+ io.WriteString(p.w, ")")
+
+ p.Print(nn.Stmt)
+
+ if nn.ElseIf != nil {
+ p.printNodes(nn.ElseIf)
+ }
+
+ if nn.Else != nil {
+ p.Print(nn.Else)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtInlineHTML(n ast.Vertex) {
+ nn := n.(*ast.StmtInlineHtml)
+ p.printFreeFloating(nn, token.Start)
+
+ if p.s == PhpState && nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, "?>")
+ }
+ p.SetState(HtmlState)
+
+ io.WriteString(p.w, string(nn.Value))
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtInterface(n ast.Vertex) {
+ nn := n.(*ast.StmtInterface)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "interface")
+
+ if nn.InterfaceName.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ p.Print(nn.InterfaceName)
+
+ if nn.Extends != nil {
+ p.printFreeFloating(nn.Extends, token.Start)
+ if nn.Extends.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "extends")
+ if nn.Extends.InterfaceNames[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Extends.InterfaceNames)
+ }
+
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtLabel(n ast.Vertex) {
+ nn := n.(*ast.StmtLabel)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.LabelName)
+ p.printFreeFloating(nn, token.Label)
+
+ io.WriteString(p.w, ":")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtNamespace(n ast.Vertex) {
+ nn := n.(*ast.StmtNamespace)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "namespace")
+
+ if nn.NamespaceName != nil {
+ if nn.NamespaceName.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.NamespaceName)
+ }
+
+ if nn.Stmts != nil {
+ p.printFreeFloating(nn, token.Namespace)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+ } else {
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtNop(n ast.Vertex) {
+ p.printFreeFloating(n, token.Start)
+ p.printFreeFloating(n, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+ p.printFreeFloating(n, token.End)
+}
+
+func (p *Printer) printStmtPropertyList(n ast.Vertex) {
+ nn := n.(*ast.StmtPropertyList)
+ p.printFreeFloating(nn, token.Start)
+
+ for k, m := range nn.Modifiers {
+ if k > 0 && m.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(m)
+ }
+
+ if nn.Type != nil && nn.Type.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ p.Print(nn.Type)
+
+ if nn.Properties[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ p.joinPrint(",", nn.Properties)
+ p.printFreeFloating(n, token.PropertyList)
+
+ p.printFreeFloating(n, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtProperty(n ast.Vertex) {
+ nn := n.(*ast.StmtProperty)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Var)
+
+ if nn.Expr != nil {
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "=")
+ p.Print(nn.Expr)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtReturn(n ast.Vertex) {
+ nn := n.(*ast.StmtReturn)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "return")
+ if nn.Expr != nil && nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtStaticVar(n ast.Vertex) {
+ nn := n.(*ast.StmtStaticVar)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Var)
+
+ if nn.Expr != nil {
+ p.printFreeFloating(nn, token.Var)
+ io.WriteString(p.w, "=")
+ p.Print(nn.Expr)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtStatic(n ast.Vertex) {
+ nn := n.(*ast.StmtStatic)
+ p.printFreeFloating(nn, token.Start)
+ io.WriteString(p.w, "static")
+
+ p.joinPrint(",", nn.Vars)
+ p.printFreeFloating(nn, token.VarList)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtStmtList(n ast.Vertex) {
+ nn := n.(*ast.StmtStmtList)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtSwitch(n ast.Vertex) {
+ nn := n.(*ast.StmtSwitch)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "switch")
+ p.printFreeFloating(nn, token.Switch)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+
+ p.printFreeFloating(nn.CaseList, token.Start)
+ io.WriteString(p.w, "{")
+ p.printFreeFloating(nn.CaseList, token.CaseListStart)
+ p.printNodes(nn.CaseList.Cases)
+ p.printFreeFloating(nn.CaseList, token.CaseListEnd)
+ io.WriteString(p.w, "}")
+ p.printFreeFloating(nn.CaseList, token.End)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtThrow(n ast.Vertex) {
+ nn := n.(*ast.StmtThrow)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "throw")
+ if nn.Expr.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Expr)
+ p.printFreeFloating(nn, token.Expr)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitAdaptationList(n ast.Vertex) {
+ nn := n.(*ast.StmtTraitAdaptationList)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Adaptations)
+ p.printFreeFloating(nn, token.AdaptationList)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitMethodRef(n ast.Vertex) {
+ nn := n.(*ast.StmtTraitMethodRef)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.Trait != nil {
+ p.Print(nn.Trait)
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "::")
+ }
+
+ p.Print(nn.Method)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitUseAlias(n ast.Vertex) {
+ nn := n.(*ast.StmtTraitUseAlias)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Ref)
+ p.printFreeFloating(nn, token.Ref)
+
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "as")
+
+ if nn.Modifier != nil {
+ if nn.Modifier.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Modifier)
+ }
+
+ if nn.Alias != nil {
+ if nn.Alias.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Alias)
+ }
+ p.printFreeFloating(nn, token.Alias)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitUsePrecedence(n ast.Vertex) {
+ nn := n.(*ast.StmtTraitUsePrecedence)
+ p.printFreeFloating(nn, token.Start)
+
+ p.Print(nn.Ref)
+ p.printFreeFloating(nn, token.Ref)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+
+ io.WriteString(p.w, "insteadof")
+ if nn.Insteadof[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Insteadof)
+ p.printFreeFloating(nn, token.NameList)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTraitUse(n ast.Vertex) {
+ nn := n.(*ast.StmtTraitUse)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "use")
+ if nn.Traits[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Traits)
+
+ p.Print(nn.TraitAdaptationList)
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTrait(n ast.Vertex) {
+ nn := n.(*ast.StmtTrait)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "trait")
+ if nn.TraitName.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.TraitName)
+
+ p.printFreeFloating(nn, token.Name)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtTry(n ast.Vertex) {
+ nn := n.(*ast.StmtTry)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "try")
+ p.printFreeFloating(nn, token.Try)
+ io.WriteString(p.w, "{")
+ p.printNodes(nn.Stmts)
+ p.printFreeFloating(nn, token.Stmts)
+ io.WriteString(p.w, "}")
+
+ if nn.Catches != nil {
+ p.printNodes(nn.Catches)
+ }
+
+ if nn.Finally != nil {
+ p.Print(nn.Finally)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtUnset(n ast.Vertex) {
+ nn := n.(*ast.StmtUnset)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "unset")
+ p.printFreeFloating(nn, token.Unset)
+ io.WriteString(p.w, "(")
+ p.joinPrint(",", nn.Vars)
+ p.printFreeFloating(nn, token.VarList)
+ io.WriteString(p.w, ")")
+ p.printFreeFloating(nn, token.CloseParenthesisToken)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if n.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtUseList(n ast.Vertex) {
+ nn := n.(*ast.StmtUseList)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "use")
+
+ if nn.UseType != nil {
+ if nn.UseType.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.UseType)
+ }
+
+ if nn.Uses[0].GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.joinPrint(",", nn.Uses)
+ p.printFreeFloating(nn, token.UseDeclarationList)
+
+ p.printFreeFloating(nn, token.SemiColon)
+ if nn.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, ";")
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtUse(n ast.Vertex) {
+ nn := n.(*ast.StmtUse)
+ p.printFreeFloating(nn, token.Start)
+
+ if nn.UseType != nil {
+ p.Print(nn.UseType)
+ if nn.UseType.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ }
+
+ p.printFreeFloating(nn, token.Slash)
+
+ p.Print(nn.Use)
+
+ if nn.Alias != nil {
+ if nn.Alias.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ io.WriteString(p.w, "as")
+ if nn.Alias.GetNode().Tokens.IsEmpty() {
+ io.WriteString(p.w, " ")
+ }
+ p.Print(nn.Alias)
+ }
+
+ p.printFreeFloating(nn, token.End)
+}
+
+func (p *Printer) printStmtWhile(n ast.Vertex) {
+ nn := n.(*ast.StmtWhile)
+ p.printFreeFloating(nn, token.Start)
+
+ io.WriteString(p.w, "while")
+ p.printFreeFloating(nn, token.While)
+ io.WriteString(p.w, "(")
+ p.Print(nn.Cond)
+ p.printFreeFloating(nn, token.Expr)
+ io.WriteString(p.w, ")")
+
+ p.Print(nn.Stmt)
+
+ p.printFreeFloating(nn, token.End)
+}
diff --git a/printer/printer_parsed_php5_test.go b/pkg/printer/printer_parsed_php5_test.go
similarity index 99%
rename from printer/printer_parsed_php5_test.go
rename to pkg/printer/printer_parsed_php5_test.go
index 660987a..14868ac 100644
--- a/printer/printer_parsed_php5_test.go
+++ b/pkg/printer/printer_parsed_php5_test.go
@@ -2,22 +2,22 @@ package printer_test
import (
"bytes"
+ "github.com/z7zmey/php-parser/pkg/ast"
"testing"
- "github.com/z7zmey/php-parser/node"
- "github.com/z7zmey/php-parser/php5"
- "github.com/z7zmey/php-parser/printer"
+ "github.com/z7zmey/php-parser/internal/php5"
+ "github.com/z7zmey/php-parser/pkg/printer"
)
-func parsePhp5(src string) node.Node {
+func parsePhp5(src string) ast.Vertex {
php5parser := php5.NewParser([]byte(src), "5.6")
- php5parser.WithFreeFloating()
+ php5parser.WithTokens()
php5parser.Parse()
return php5parser.GetRootNode()
}
-func printPhp5(n node.Node) string {
+func printPhp5(n ast.Vertex) string {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
diff --git a/printer/printer_parsed_php7_test.go b/pkg/printer/printer_parsed_php7_test.go
similarity index 98%
rename from printer/printer_parsed_php7_test.go
rename to pkg/printer/printer_parsed_php7_test.go
index d50dc59..971219f 100644
--- a/printer/printer_parsed_php7_test.go
+++ b/pkg/printer/printer_parsed_php7_test.go
@@ -2,14 +2,12 @@ package printer_test
import (
"bytes"
+ "github.com/z7zmey/php-parser/pkg/ast"
"os"
"testing"
- "github.com/z7zmey/php-parser/node"
- "github.com/z7zmey/php-parser/node/name"
- "github.com/z7zmey/php-parser/node/stmt"
- "github.com/z7zmey/php-parser/php7"
- "github.com/z7zmey/php-parser/printer"
+ "github.com/z7zmey/php-parser/internal/php7"
+ "github.com/z7zmey/php-parser/pkg/printer"
)
func ExamplePrinter() {
@@ -30,15 +28,15 @@ abstract class Bar extends Baz
// parse
php7parser := php7.NewParser([]byte(src), "7.4")
- php7parser.WithFreeFloating()
+ php7parser.WithTokens()
php7parser.Parse()
rootNode := php7parser.GetRootNode()
// change namespace
- parts := &rootNode.(*node.Root).Stmts[0].(*stmt.Namespace).NamespaceName.(*name.Name).Parts
- *parts = append(*parts, &name.NamePart{Value: "Quuz"})
+ parts := &rootNode.(*ast.Root).Stmts[0].(*ast.StmtNamespace).NamespaceName.(*ast.NameName).Parts
+ *parts = append(*parts, &ast.NameNamePart{Value: []byte("Quuz")})
// print
@@ -60,15 +58,15 @@ abstract class Bar extends Baz
// }
}
-func parse(src string) node.Node {
+func parse(src string) ast.Vertex {
php7parser := php7.NewParser([]byte(src), "7.4")
- php7parser.WithFreeFloating()
+ php7parser.WithTokens()
php7parser.Parse()
return php7parser.GetRootNode()
}
-func print(n node.Node) string {
+func print(n ast.Vertex) string {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
diff --git a/printer/printer_test.go b/pkg/printer/printer_test.go
similarity index 54%
rename from printer/printer_test.go
rename to pkg/printer/printer_test.go
index 331de66..a2df1a1 100644
--- a/printer/printer_test.go
+++ b/pkg/printer/printer_test.go
@@ -2,56 +2,49 @@ package printer_test
import (
"bytes"
+ "github.com/z7zmey/php-parser/pkg/ast"
+ "github.com/z7zmey/php-parser/pkg/token"
"testing"
- "github.com/z7zmey/php-parser/freefloating"
- "github.com/z7zmey/php-parser/node"
- "github.com/z7zmey/php-parser/node/expr"
- "github.com/z7zmey/php-parser/node/expr/assign"
- "github.com/z7zmey/php-parser/node/expr/binary"
- "github.com/z7zmey/php-parser/node/expr/cast"
- "github.com/z7zmey/php-parser/node/name"
- "github.com/z7zmey/php-parser/node/scalar"
- "github.com/z7zmey/php-parser/node/stmt"
- "github.com/z7zmey/php-parser/printer"
+ "github.com/z7zmey/php-parser/pkg/printer"
)
func TestPrinterPrintFile(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Root{
- Stmts: []node.Node{
- &stmt.Namespace{
- NamespaceName: &name.Name{
- Parts: []node.Node{
- &name.NamePart{Value: "Foo"},
+ p.Print(&ast.Root{
+ Stmts: []ast.Vertex{
+ &ast.StmtNamespace{
+ NamespaceName: &ast.NameName{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{Value: []byte("Foo")},
},
},
},
- &stmt.Class{
- Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
- ClassName: &name.Name{
- Parts: []node.Node{
- &name.NamePart{Value: "Bar"},
+ &ast.StmtClass{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+ ClassName: &ast.NameName{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{Value: []byte("Bar")},
},
},
- Extends: &stmt.ClassExtends{
- ClassName: &name.Name{
- Parts: []node.Node{
- &name.NamePart{Value: "Baz"},
+ Extends: &ast.StmtClassExtends{
+ ClassName: &ast.NameName{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{Value: []byte("Baz")},
},
},
},
- Stmts: []node.Node{
- &stmt.ClassMethod{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- MethodName: &node.Identifier{Value: "greet"},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Echo{
- Exprs: []node.Node{
- &scalar.String{Value: "'Hello world'"},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ MethodName: &ast.Identifier{Value: []byte("greet")},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtEcho{
+ Exprs: []ast.Vertex{
+ &ast.ScalarString{Value: []byte("'Hello world'")},
},
},
},
@@ -74,37 +67,41 @@ func TestPrinterPrintFileInlineHtml(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Root{
- Stmts: []node.Node{
- &stmt.InlineHtml{Value: "HTML
"},
- &stmt.Expression{
- Expr: &expr.Variable{
- FreeFloating: freefloating.Collection{
- freefloating.Start: []freefloating.String{
- {
- StringType: freefloating.TokenType,
- Value: "$",
+ p.Print(&ast.Root{
+ Stmts: []ast.Vertex{
+ &ast.StmtInlineHtml{Value: []byte("HTML
")},
+ &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ Node: ast.Node{
+ Tokens: token.Collection{
+ token.Start: []token.Token{
+ {
+ ID: token.ID('$'),
+ Value: []byte("$"),
+ },
},
},
},
- VarName: &node.Identifier{
- Value: "a",
+ VarName: &ast.Identifier{
+ Value: []byte("a"),
},
},
},
- &stmt.InlineHtml{Value: "HTML
"},
- &stmt.Expression{
- Expr: &expr.Variable{
- FreeFloating: freefloating.Collection{
- freefloating.Start: []freefloating.String{
- {
- StringType: freefloating.TokenType,
- Value: "$",
+ &ast.StmtInlineHtml{Value: []byte("HTML
")},
+ &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ Node: ast.Node{
+ Tokens: token.Collection{
+ token.Start: []token.Token{
+ {
+ ID: token.ID('$'),
+ Value: []byte("$"),
+ },
},
},
},
- VarName: &node.Identifier{
- Value: "a",
+ VarName: &ast.Identifier{
+ Value: []byte("a"),
},
},
},
@@ -125,8 +122,8 @@ func TestPrinterPrintIdentifier(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- n := &node.Identifier{
- Value: "test",
+ n := &ast.Identifier{
+ Value: []byte("test"),
}
p.Print(n)
@@ -142,21 +139,21 @@ func TestPrinterPrintParameter(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Parameter{
+ p.Print(&ast.Parameter{
ByRef: false,
Variadic: true,
- VariableType: &name.FullyQualified{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ Type: &ast.NameFullyQualified{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
},
},
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
- DefaultValue: &scalar.String{
- Value: "'default'",
+ DefaultValue: &ast.ScalarString{
+ Value: []byte("'default'"),
},
})
@@ -172,24 +169,24 @@ func TestPrinterPrintNullable(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Nullable{
- Expr: &node.Parameter{
+ p.Print(&ast.Nullable{
+ Expr: &ast.Parameter{
ByRef: true,
Variadic: false,
- VariableType: &name.FullyQualified{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ Type: &ast.NameFullyQualified{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
},
},
- Variable: &expr.Variable{
- VarName: &node.Identifier{
- Value: "var",
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{
+ Value: []byte("var"),
},
},
- DefaultValue: &scalar.String{
- Value: "'default'",
+ DefaultValue: &ast.ScalarString{
+ Value: []byte("'default'"),
},
},
})
@@ -206,12 +203,12 @@ func TestPrinterPrintArgument(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Argument{
+ p.Print(&ast.Argument{
IsReference: false,
Variadic: true,
- Expr: &expr.Variable{
- VarName: &node.Identifier{
- Value: "var",
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{
+ Value: []byte("var"),
},
},
})
@@ -227,12 +224,12 @@ func TestPrinterPrintArgumentByRef(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Argument{
+ p.Print(&ast.Argument{
IsReference: true,
Variadic: false,
- Expr: &expr.Variable{
- VarName: &node.Identifier{
- Value: "var",
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{
+ Value: []byte("var"),
},
},
})
@@ -251,8 +248,8 @@ func TestPrinterPrintNameNamePart(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&name.NamePart{
- Value: "foo",
+ p.Print(&ast.NameNamePart{
+ Value: []byte("foo"),
})
expected := "foo"
@@ -267,13 +264,13 @@ func TestPrinterPrintNameName(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&name.Name{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ p.Print(&ast.NameName{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
- &name.NamePart{
- Value: "Bar",
+ &ast.NameNamePart{
+ Value: []byte("Bar"),
},
},
})
@@ -290,13 +287,13 @@ func TestPrinterPrintNameFullyQualified(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&name.FullyQualified{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ p.Print(&ast.NameFullyQualified{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
- &name.NamePart{
- Value: "Bar",
+ &ast.NameNamePart{
+ Value: []byte("Bar"),
},
},
})
@@ -313,13 +310,13 @@ func TestPrinterPrintNameRelative(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&name.Relative{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ p.Print(&ast.NameRelative{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
- &name.NamePart{
- Value: "Bar",
+ &ast.NameNamePart{
+ Value: []byte("Bar"),
},
},
})
@@ -338,8 +335,8 @@ func TestPrinterPrintScalarLNumber(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&scalar.Lnumber{
- Value: "1",
+ p.Print(&ast.ScalarLnumber{
+ Value: []byte("1"),
})
expected := "1"
@@ -354,8 +351,8 @@ func TestPrinterPrintScalarDNumber(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&scalar.Dnumber{
- Value: ".1",
+ p.Print(&ast.ScalarDnumber{
+ Value: []byte(".1"),
})
expected := ".1"
@@ -370,8 +367,8 @@ func TestPrinterPrintScalarString(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&scalar.String{
- Value: "'hello world'",
+ p.Print(&ast.ScalarString{
+ Value: []byte("'hello world'"),
})
expected := `'hello world'`
@@ -386,8 +383,8 @@ func TestPrinterPrintScalarEncapsedStringPart(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&scalar.EncapsedStringPart{
- Value: "hello world",
+ p.Print(&ast.ScalarEncapsedStringPart{
+ Value: []byte("hello world"),
})
expected := `hello world`
@@ -402,13 +399,13 @@ func TestPrinterPrintScalarEncapsed(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&scalar.Encapsed{
- Parts: []node.Node{
- &scalar.EncapsedStringPart{Value: "hello "},
- &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.ScalarEncapsed{
+ Parts: []ast.Vertex{
+ &ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
- &scalar.EncapsedStringPart{Value: " world"},
+ &ast.ScalarEncapsedStringPart{Value: []byte(" world")},
},
})
@@ -424,14 +421,14 @@ func TestPrinterPrintScalarHeredoc(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&scalar.Heredoc{
- Label: "<<bar`
@@ -2221,9 +2218,9 @@ func TestPrinterPrintExprReference(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Reference{
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "foo"},
+ p.Print(&ast.ExprReference{
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("foo")},
},
})
@@ -2239,8 +2236,8 @@ func TestPrinterPrintRequire(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Require{
- Expr: &scalar.String{Value: "'path'"},
+ p.Print(&ast.ExprRequire{
+ Expr: &ast.ScalarString{Value: []byte("'path'")},
})
expected := `require 'path'`
@@ -2255,8 +2252,8 @@ func TestPrinterPrintRequireOnce(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.RequireOnce{
- Expr: &scalar.String{Value: "'path'"},
+ p.Print(&ast.ExprRequireOnce{
+ Expr: &ast.ScalarString{Value: []byte("'path'")},
})
expected := `require_once 'path'`
@@ -2271,13 +2268,13 @@ func TestPrinterPrintShellExec(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.ShellExec{
- Parts: []node.Node{
- &scalar.EncapsedStringPart{Value: "hello "},
- &expr.Variable{
- VarName: &node.Identifier{Value: "world"},
+ p.Print(&ast.ExprShellExec{
+ Parts: []ast.Vertex{
+ &ast.ScalarEncapsedStringPart{Value: []byte("hello ")},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("world")},
},
- &scalar.EncapsedStringPart{Value: "!"},
+ &ast.ScalarEncapsedStringPart{Value: []byte("!")},
},
})
@@ -2293,23 +2290,23 @@ func TestPrinterPrintExprShortArray(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.ShortArray{
- Items: []node.Node{
- &expr.ArrayItem{
- Key: &scalar.String{Value: "'Hello'"},
- Val: &expr.Variable{
- VarName: &node.Identifier{Value: "world"},
+ p.Print(&ast.ExprShortArray{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Key: &ast.ScalarString{Value: []byte("'Hello'")},
+ Val: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("world")},
},
},
- &expr.ArrayItem{
- Key: &scalar.Lnumber{Value: "2"},
- Val: &expr.Reference{Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ &ast.ExprArrayItem{
+ Key: &ast.ScalarLnumber{Value: []byte("2")},
+ Val: &ast.ExprReference{Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
}},
},
- &expr.ArrayItem{
- Val: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
},
},
@@ -2327,24 +2324,24 @@ func TestPrinterPrintShortList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.ShortList{
- Items: []node.Node{
- &expr.ArrayItem{
- Val: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.ExprShortList{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
},
- &expr.ArrayItem{
- Val: &expr.List{
- Items: []node.Node{
- &expr.ArrayItem{
- Val: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprList{
+ Items: []ast.Vertex{
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
- &expr.ArrayItem{
- Val: &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ &ast.ExprArrayItem{
+ Val: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
},
},
},
@@ -2365,19 +2362,19 @@ func TestPrinterPrintStaticCall(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.StaticCall{
- Class: &node.Identifier{Value: "Foo"},
- Call: &node.Identifier{Value: "bar"},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.ExprStaticCall{
+ Class: &ast.Identifier{Value: []byte("Foo")},
+ Call: &ast.Identifier{Value: []byte("bar")},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
},
- &node.Argument{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
@@ -2396,10 +2393,10 @@ func TestPrinterPrintStaticPropertyFetch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.StaticPropertyFetch{
- Class: &node.Identifier{Value: "Foo"},
- Property: &expr.Variable{
- VarName: &node.Identifier{Value: "bar"},
+ p.Print(&ast.ExprStaticPropertyFetch{
+ Class: &ast.Identifier{Value: []byte("Foo")},
+ Property: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("bar")},
},
})
@@ -2415,12 +2412,12 @@ func TestPrinterPrintTernary(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Ternary{
- Condition: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.ExprTernary{
+ Condition: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- IfFalse: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ IfFalse: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
})
@@ -2436,15 +2433,15 @@ func TestPrinterPrintTernaryFull(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Ternary{
- Condition: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.ExprTernary{
+ Condition: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- IfTrue: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ IfTrue: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
- IfFalse: &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ IfFalse: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
},
})
@@ -2460,9 +2457,9 @@ func TestPrinterPrintUnaryMinus(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.UnaryMinus{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.ExprUnaryMinus{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -2478,9 +2475,9 @@ func TestPrinterPrintUnaryPlus(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.UnaryPlus{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.ExprUnaryPlus{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -2496,9 +2493,9 @@ func TestPrinterPrintVariable(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Variable{
- VarName: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.ExprVariable{
+ VarName: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -2514,9 +2511,9 @@ func TestPrinterPrintYieldFrom(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.YieldFrom{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.ExprYieldFrom{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -2532,9 +2529,9 @@ func TestPrinterPrintYield(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Yield{
- Value: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.ExprYield{
+ Value: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -2550,12 +2547,12 @@ func TestPrinterPrintYieldFull(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&expr.Yield{
- Key: &expr.Variable{
- VarName: &node.Identifier{Value: "k"},
+ p.Print(&ast.ExprYield{
+ Key: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("k")},
},
- Value: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ Value: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -2573,14 +2570,14 @@ func TestPrinterPrintAltElseIf(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
@@ -2598,11 +2595,11 @@ func TestPrinterPrintAltElseIfEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{},
+ Stmt: &ast.StmtStmtList{},
})
expected := `elseif($a):`
@@ -2617,11 +2614,11 @@ func TestPrinterPrintAltElse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltElse{
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ p.Print(&ast.StmtAltElse{
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
@@ -2639,8 +2636,8 @@ func TestPrinterPrintAltElseEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltElse{
- Stmt: &stmt.StmtList{},
+ p.Print(&ast.StmtAltElse{
+ Stmt: &ast.StmtStmtList{},
})
expected := `else:`
@@ -2655,26 +2652,26 @@ func TestPrinterPrintAltFor(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltFor{
- Init: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtAltFor{
+ Init: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
},
- Cond: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Cond: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
- Loop: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ Loop: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "d"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("d")},
}},
},
},
@@ -2692,20 +2689,20 @@ func TestPrinterPrintAltForeach(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltForeach{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.StmtAltForeach{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
- Key: &expr.Variable{
- VarName: &node.Identifier{Value: "key"},
+ Key: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("key")},
},
- Variable: &expr.Reference{Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "val"},
+ Var: &ast.ExprReference{Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("val")},
}},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "d"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("d")},
}},
},
},
@@ -2723,42 +2720,42 @@ func TestPrinterPrintAltIf(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtAltIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "d"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("d")},
}},
},
},
- ElseIf: []node.Node{
- &stmt.AltElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ ElseIf: []ast.Vertex{
+ &ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
},
- &stmt.AltElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ &ast.StmtAltElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
},
- Stmt: &stmt.StmtList{},
+ Stmt: &ast.StmtStmtList{},
},
},
- Else: &stmt.AltElse{
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Else: &ast.StmtAltElse{
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
@@ -2777,25 +2774,25 @@ func TestPrinterPrintStmtAltSwitch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltSwitch{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.StmtAltSwitch{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
- CaseList: &stmt.CaseList{
- Cases: []node.Node{
- &stmt.Case{
- Cond: &scalar.String{Value: "'a'"},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ CaseList: &ast.StmtCaseList{
+ Cases: []ast.Vertex{
+ &ast.StmtCase{
+ Cond: &ast.ScalarString{Value: []byte("'a'")},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
- &stmt.Case{
- Cond: &scalar.String{Value: "'b'"},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.StmtCase{
+ Cond: &ast.ScalarString{Value: []byte("'b'")},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
@@ -2815,14 +2812,14 @@ func TestPrinterPrintAltWhile(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.AltWhile{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtAltWhile{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
@@ -2840,9 +2837,9 @@ func TestPrinterPrintStmtBreak(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Break{
- Expr: &scalar.Lnumber{
- Value: "1",
+ p.Print(&ast.StmtBreak{
+ Expr: &ast.ScalarLnumber{
+ Value: []byte("1"),
},
})
@@ -2858,13 +2855,13 @@ func TestPrinterPrintStmtCase(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Case{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtCase{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
})
@@ -2881,11 +2878,11 @@ func TestPrinterPrintStmtCaseEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Case{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtCase{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmts: []node.Node{},
+ Stmts: []ast.Vertex{},
})
expected := "case $a:"
@@ -2900,17 +2897,17 @@ func TestPrinterPrintStmtCatch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Catch{
- Types: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
- &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+ p.Print(&ast.StmtCatch{
+ Types: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+ &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
},
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "e"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("e")},
},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
})
@@ -2927,33 +2924,33 @@ func TestPrinterPrintStmtClassMethod(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ClassMethod{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
+ p.Print(&ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
ReturnsRef: true,
- MethodName: &node.Identifier{Value: "foo"},
- Params: []node.Node{
- &node.Parameter{
- ByRef: true,
- VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ MethodName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{
+ &ast.Parameter{
+ ByRef: true,
+ Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+ DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
},
- &node.Parameter{
+ &ast.Parameter{
Variadic: true,
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
- ReturnType: &name.Name{
- Parts: []node.Node{&name.NamePart{Value: "void"}},
+ ReturnType: &ast.NameName{
+ Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
@@ -2971,33 +2968,33 @@ func TestPrinterPrintStmtAbstractClassMethod(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ClassMethod{
- Modifiers: []node.Node{
- &node.Identifier{Value: "public"},
- &node.Identifier{Value: "static"},
+ p.Print(&ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{
+ &ast.Identifier{Value: []byte("public")},
+ &ast.Identifier{Value: []byte("static")},
},
ReturnsRef: true,
- MethodName: &node.Identifier{Value: "foo"},
- Params: []node.Node{
- &node.Parameter{
- ByRef: true,
- VariableType: &node.Nullable{Expr: &name.Name{Parts: []node.Node{&name.NamePart{Value: "int"}}}},
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ MethodName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{
+ &ast.Parameter{
+ ByRef: true,
+ Type: &ast.Nullable{Expr: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("int")}}}},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- DefaultValue: &expr.ConstFetch{Constant: &name.Name{Parts: []node.Node{&name.NamePart{Value: "null"}}}},
+ DefaultValue: &ast.ExprConstFetch{Const: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("null")}}}},
},
- &node.Parameter{
+ &ast.Parameter{
Variadic: true,
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
- ReturnType: &name.Name{
- Parts: []node.Node{&name.NamePart{Value: "void"}},
+ ReturnType: &ast.NameName{
+ Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("void")}},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
})
expected := `public static function &foo(?int&$a=null,...$b):void;`
@@ -3012,28 +3009,28 @@ func TestPrinterPrintStmtClass(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Class{
- Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
- ClassName: &node.Identifier{Value: "Foo"},
- Extends: &stmt.ClassExtends{
- ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+ p.Print(&ast.StmtClass{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+ ClassName: &ast.Identifier{Value: []byte("Foo")},
+ Extends: &ast.StmtClassExtends{
+ ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
},
- Implements: &stmt.ClassImplements{
- InterfaceNames: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+ Implements: &ast.StmtClassImplements{
+ InterfaceNames: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
- Stmts: []node.Node{
- &stmt.ClassConstList{
- Modifiers: []node.Node{
- &node.Identifier{Value: "public"},
- &node.Identifier{Value: "static"},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassConstList{
+ Modifiers: []ast.Vertex{
+ &ast.Identifier{Value: []byte("public")},
+ &ast.Identifier{Value: []byte("static")},
},
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
},
@@ -3052,38 +3049,38 @@ func TestPrinterPrintStmtAnonymousClass(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Class{
- Modifiers: []node.Node{&node.Identifier{Value: "abstract"}},
- ArgumentList: &node.ArgumentList{
- Arguments: []node.Node{
- &node.Argument{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtClass{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("abstract")}},
+ ArgumentList: &ast.ArgumentList{
+ Arguments: []ast.Vertex{
+ &ast.Argument{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
},
- &node.Argument{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.Argument{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
},
- Extends: &stmt.ClassExtends{
- ClassName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+ Extends: &ast.StmtClassExtends{
+ ClassName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
},
- Implements: &stmt.ClassImplements{
- InterfaceNames: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+ Implements: &ast.StmtClassImplements{
+ InterfaceNames: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
- Stmts: []node.Node{
- &stmt.ClassConstList{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassConstList{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
},
@@ -3102,16 +3099,16 @@ func TestPrinterPrintStmtClassConstList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ClassConstList{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'a'"},
+ p.Print(&ast.StmtClassConstList{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'a'")},
},
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "BAR"},
- Expr: &scalar.String{Value: "'b'"},
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("BAR")},
+ Expr: &ast.ScalarString{Value: []byte("'b'")},
},
},
})
@@ -3128,15 +3125,15 @@ func TestPrinterPrintStmtConstList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ConstList{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'a'"},
+ p.Print(&ast.StmtConstList{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'a'")},
},
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "BAR"},
- Expr: &scalar.String{Value: "'b'"},
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("BAR")},
+ Expr: &ast.ScalarString{Value: []byte("'b'")},
},
},
})
@@ -3153,9 +3150,9 @@ func TestPrinterPrintStmtConstant(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'BAR'"},
+ p.Print(&ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'BAR'")},
})
expected := "FOO='BAR'"
@@ -3170,9 +3167,9 @@ func TestPrinterPrintStmtContinue(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Continue{
- Expr: &scalar.Lnumber{
- Value: "1",
+ p.Print(&ast.StmtContinue{
+ Expr: &ast.ScalarLnumber{
+ Value: []byte("1"),
},
})
@@ -3188,16 +3185,16 @@ func TestPrinterPrintStmtDeclareStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Declare{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ p.Print(&ast.StmtDeclare{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -3214,14 +3211,14 @@ func TestPrinterPrintStmtDeclareExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Declare{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ p.Print(&ast.StmtDeclare{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
})
expected := `declare(FOO='bar')'bar';`
@@ -3236,14 +3233,14 @@ func TestPrinterPrintStmtDeclareNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Declare{
- Consts: []node.Node{
- &stmt.Constant{
- ConstantName: &node.Identifier{Value: "FOO"},
- Expr: &scalar.String{Value: "'bar'"},
+ p.Print(&ast.StmtDeclare{
+ Consts: []ast.Vertex{
+ &ast.StmtConstant{
+ ConstantName: &ast.Identifier{Value: []byte("FOO")},
+ Expr: &ast.ScalarString{Value: []byte("'bar'")},
},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
})
expected := `declare(FOO='bar');`
@@ -3258,10 +3255,10 @@ func TestPrinterPrintStmtDefalut(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Default{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtDefault{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
})
@@ -3278,8 +3275,8 @@ func TestPrinterPrintStmtDefalutEmpty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Default{
- Stmts: []node.Node{},
+ p.Print(&ast.StmtDefault{
+ Stmts: []ast.Vertex{},
})
expected := `default:`
@@ -3294,11 +3291,11 @@ func TestPrinterPrintStmtDo_Expression(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Do{
- Cond: &scalar.Lnumber{Value: "1"},
- Stmt: &stmt.Expression{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtDo{
+ Cond: &ast.ScalarLnumber{Value: []byte("1")},
+ Stmt: &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
},
})
@@ -3315,12 +3312,12 @@ func TestPrinterPrintStmtDo_StmtList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Do{
- Cond: &scalar.Lnumber{Value: "1"},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtDo{
+ Cond: &ast.ScalarLnumber{Value: []byte("1")},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
@@ -3338,15 +3335,15 @@ func TestPrinterPrintStmtEchoHtmlState(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Root{
- Stmts: []node.Node{
- &stmt.Echo{
- Exprs: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.Root{
+ Stmts: []ast.Vertex{
+ &ast.StmtEcho{
+ Exprs: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
@@ -3365,13 +3362,13 @@ func TestPrinterPrintStmtEchoPhpState(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Echo{
- Exprs: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtEcho{
+ Exprs: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
})
@@ -3388,13 +3385,13 @@ func TestPrinterPrintStmtElseIfStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -3411,11 +3408,11 @@ func TestPrinterPrintStmtElseIfExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
})
expected := `elseif($a)'bar';`
@@ -3430,11 +3427,11 @@ func TestPrinterPrintStmtElseIfNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.ElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
})
expected := `elseif($a);`
@@ -3449,10 +3446,10 @@ func TestPrinterPrintStmtElseStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Else{
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ p.Print(&ast.StmtElse{
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -3469,8 +3466,8 @@ func TestPrinterPrintStmtElseExpr(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Else{
- Stmt: &stmt.Expression{Expr: &scalar.String{Value: "'bar'"}},
+ p.Print(&ast.StmtElse{
+ Stmt: &ast.StmtExpression{Expr: &ast.ScalarString{Value: []byte("'bar'")}},
})
expected := `else 'bar';`
@@ -3485,8 +3482,8 @@ func TestPrinterPrintStmtElseNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Else{
- Stmt: &stmt.Nop{},
+ p.Print(&ast.StmtElse{
+ Stmt: &ast.StmtNop{},
})
expected := `else ;`
@@ -3501,9 +3498,9 @@ func TestPrinterPrintExpression(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Expression{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
})
@@ -3519,9 +3516,9 @@ func TestPrinterPrintStmtFinally(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Finally{
- Stmts: []node.Node{
- &stmt.Nop{},
+ p.Print(&ast.StmtFinally{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
})
@@ -3537,34 +3534,34 @@ func TestPrinterPrintStmtFor(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.For{
- Init: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtFor{
+ Init: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
- Cond: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ Cond: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "d"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("d")},
},
},
- Loop: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "e"},
+ Loop: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("e")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "f"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("f")},
},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -3581,19 +3578,19 @@ func TestPrinterPrintStmtForeach(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Foreach{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtForeach{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Key: &expr.Variable{
- VarName: &node.Identifier{Value: "k"},
+ Key: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("k")},
},
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "v"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("v")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -3610,23 +3607,23 @@ func TestPrinterPrintStmtFunction(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Function{
+ p.Print(&ast.StmtFunction{
ReturnsRef: true,
- FunctionName: &node.Identifier{Value: "foo"},
- Params: []node.Node{
- &node.Parameter{
+ FunctionName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{
+ &ast.Parameter{
ByRef: true,
Variadic: false,
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
},
},
- ReturnType: &name.FullyQualified{
- Parts: []node.Node{&name.NamePart{Value: "Foo"}},
+ ReturnType: &ast.NameFullyQualified{
+ Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}},
},
- Stmts: []node.Node{
- &stmt.Nop{},
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
})
@@ -3642,13 +3639,13 @@ func TestPrinterPrintStmtGlobal(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Global{
- Vars: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtGlobal{
+ Vars: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
})
@@ -3665,8 +3662,8 @@ func TestPrinterPrintStmtGoto(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Goto{
- Label: &node.Identifier{Value: "FOO"},
+ p.Print(&ast.StmtGoto{
+ Label: &ast.Identifier{Value: []byte("FOO")},
})
expected := `goto FOO;`
@@ -3681,16 +3678,16 @@ func TestPrinterPrintStmtGroupUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.GroupUse{
- UseType: &node.Identifier{Value: "function"},
- Prefix: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- UseList: []node.Node{
- &stmt.Use{
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
- Alias: &node.Identifier{Value: "Baz"},
+ p.Print(&ast.StmtGroupUse{
+ UseType: &ast.Identifier{Value: []byte("function")},
+ Prefix: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ UseList: []ast.Vertex{
+ &ast.StmtUse{
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+ Alias: &ast.Identifier{Value: []byte("Baz")},
},
- &stmt.Use{
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Quuz"}}},
+ &ast.StmtUse{
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
})
@@ -3707,7 +3704,7 @@ func TestPrinterPrintHaltCompiler(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.HaltCompiler{})
+ p.Print(&ast.StmtHaltCompiler{})
expected := `__halt_compiler();`
actual := o.String()
@@ -3721,41 +3718,41 @@ func TestPrinterPrintIfExpression(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.If{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.Expression{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Stmt: &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
- ElseIf: []node.Node{
- &stmt.ElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ ElseIf: []ast.Vertex{
+ &ast.StmtElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "d"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("d")},
},
},
},
},
},
- &stmt.ElseIf{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "e"},
+ &ast.StmtElseIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("e")},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
},
},
- Else: &stmt.Else{
- Stmt: &stmt.Expression{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "f"},
+ Else: &ast.StmtElse{
+ Stmt: &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("f")},
},
},
},
@@ -3773,15 +3770,15 @@ func TestPrinterPrintIfStmtList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.If{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
@@ -3800,11 +3797,11 @@ func TestPrinterPrintIfNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.If{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtIf{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.Nop{},
+ Stmt: &ast.StmtNop{},
})
expected := `if($a);`
@@ -3819,10 +3816,10 @@ func TestPrinterPrintInlineHtml(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&node.Root{
- Stmts: []node.Node{
- &stmt.InlineHtml{
- Value: "test",
+ p.Print(&ast.Root{
+ Stmts: []ast.Vertex{
+ &ast.StmtInlineHtml{
+ Value: []byte("test"),
},
},
})
@@ -3839,23 +3836,23 @@ func TestPrinterPrintInterface(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Interface{
- InterfaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Extends: &stmt.InterfaceExtends{
- InterfaceNames: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+ p.Print(&ast.StmtInterface{
+ InterfaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Extends: &ast.StmtInterfaceExtends{
+ InterfaceNames: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
},
- Stmts: []node.Node{
- &stmt.ClassMethod{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- MethodName: &node.Identifier{Value: "foo"},
- Params: []node.Node{},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ MethodName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
@@ -3875,8 +3872,8 @@ func TestPrinterPrintLabel(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Label{
- LabelName: &node.Identifier{Value: "FOO"},
+ p.Print(&ast.StmtLabel{
+ LabelName: &ast.Identifier{Value: []byte("FOO")},
})
expected := `FOO:`
@@ -3891,8 +3888,8 @@ func TestPrinterPrintNamespace(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Namespace{
- NamespaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
+ p.Print(&ast.StmtNamespace{
+ NamespaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
})
expected := `namespace Foo;`
@@ -3907,11 +3904,11 @@ func TestPrinterPrintNamespaceWithStmts(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Namespace{
- NamespaceName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtNamespace{
+ NamespaceName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
})
@@ -3928,7 +3925,7 @@ func TestPrinterPrintNop(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Nop{})
+ p.Print(&ast.StmtNop{})
expected := `;`
actual := o.String()
@@ -3942,28 +3939,28 @@ func TestPrinterPrintPropertyList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.PropertyList{
- Modifiers: []node.Node{
- &node.Identifier{Value: "public"},
- &node.Identifier{Value: "static"},
+ p.Print(&ast.StmtPropertyList{
+ Modifiers: []ast.Vertex{
+ &ast.Identifier{Value: []byte("public")},
+ &ast.Identifier{Value: []byte("static")},
},
- Type: &name.Name{
- Parts: []node.Node{
- &name.NamePart{
- Value: "Foo",
+ Type: &ast.NameName{
+ Parts: []ast.Vertex{
+ &ast.NameNamePart{
+ Value: []byte("Foo"),
},
},
},
- Properties: []node.Node{
- &stmt.Property{
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ Properties: []ast.Vertex{
+ &ast.StmtProperty{
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Expr: &scalar.String{Value: "'a'"},
+ Expr: &ast.ScalarString{Value: []byte("'a'")},
},
- &stmt.Property{
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.StmtProperty{
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
@@ -3981,19 +3978,21 @@ func TestPrinterPrintProperty(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Property{
- Variable: &expr.Variable{
- FreeFloating: freefloating.Collection{
- freefloating.Start: []freefloating.String{
- {
- StringType: freefloating.TokenType,
- Value: "$",
+ p.Print(&ast.StmtProperty{
+ Var: &ast.ExprVariable{
+ Node: ast.Node{
+ Tokens: token.Collection{
+ token.Start: []token.Token{
+ {
+ ID: token.ID('$'),
+ Value: []byte("$"),
+ },
},
},
},
- VarName: &node.Identifier{Value: "a"},
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Expr: &scalar.Lnumber{Value: "1"},
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
})
expected := `$a=1`
@@ -4008,8 +4007,8 @@ func TestPrinterPrintReturn(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Return{
- Expr: &scalar.Lnumber{Value: "1"},
+ p.Print(&ast.StmtReturn{
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
})
expected := `return 1;`
@@ -4024,11 +4023,11 @@ func TestPrinterPrintStaticVar(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.StaticVar{
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtStaticVar{
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Expr: &scalar.Lnumber{Value: "1"},
+ Expr: &ast.ScalarLnumber{Value: []byte("1")},
})
expected := `$a=1`
@@ -4043,16 +4042,16 @@ func TestPrinterPrintStatic(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Static{
- Vars: []node.Node{
- &stmt.StaticVar{
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtStatic{
+ Vars: []ast.Vertex{
+ &ast.StmtStaticVar{
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
},
- &stmt.StaticVar{
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.StmtStaticVar{
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
},
@@ -4070,13 +4069,13 @@ func TestPrinterPrintStmtList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
})
@@ -4093,20 +4092,20 @@ func TestPrinterPrintStmtListNested(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
- &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
- &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "c"},
+ &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("c")},
}},
},
},
@@ -4127,25 +4126,25 @@ func TestPrinterPrintStmtSwitch(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Switch{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.StmtSwitch{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
- CaseList: &stmt.CaseList{
- Cases: []node.Node{
- &stmt.Case{
- Cond: &scalar.String{Value: "'a'"},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ CaseList: &ast.StmtCaseList{
+ Cases: []ast.Vertex{
+ &ast.StmtCase{
+ Cond: &ast.ScalarString{Value: []byte("'a'")},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
- &stmt.Case{
- Cond: &scalar.String{Value: "'b'"},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.StmtCase{
+ Cond: &ast.ScalarString{Value: []byte("'b'")},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
@@ -4165,9 +4164,9 @@ func TestPrinterPrintStmtThrow(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Throw{
- Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "var"},
+ p.Print(&ast.StmtThrow{
+ Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("var")},
},
})
@@ -4183,14 +4182,14 @@ func TestPrinterPrintStmtTraitAdaptationList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitAdaptationList{
- Adaptations: []node.Node{
- &stmt.TraitUseAlias{
- Ref: &stmt.TraitMethodRef{
- Trait: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Method: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTraitAdaptationList{
+ Adaptations: []ast.Vertex{
+ &ast.StmtTraitUseAlias{
+ Ref: &ast.StmtTraitMethodRef{
+ Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Method: &ast.Identifier{Value: []byte("a")},
},
- Alias: &node.Identifier{Value: "b"},
+ Alias: &ast.Identifier{Value: []byte("b")},
},
},
})
@@ -4207,8 +4206,8 @@ func TestPrinterPrintStmtTraitMethodRef(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitMethodRef{
- Method: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTraitMethodRef{
+ Method: &ast.Identifier{Value: []byte("a")},
})
expected := `a`
@@ -4223,9 +4222,9 @@ func TestPrinterPrintStmtTraitMethodRefFull(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitMethodRef{
- Trait: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Method: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTraitMethodRef{
+ Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Method: &ast.Identifier{Value: []byte("a")},
})
expected := `Foo::a`
@@ -4240,13 +4239,13 @@ func TestPrinterPrintStmtTraitUseAlias(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitUseAlias{
- Ref: &stmt.TraitMethodRef{
- Trait: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Method: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTraitUseAlias{
+ Ref: &ast.StmtTraitMethodRef{
+ Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Method: &ast.Identifier{Value: []byte("a")},
},
- Modifier: &node.Identifier{Value: "public"},
- Alias: &node.Identifier{Value: "b"},
+ Modifier: &ast.Identifier{Value: []byte("public")},
+ Alias: &ast.Identifier{Value: []byte("b")},
})
expected := `Foo::a as public b;`
@@ -4261,14 +4260,14 @@ func TestPrinterPrintStmtTraitUsePrecedence(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitUsePrecedence{
- Ref: &stmt.TraitMethodRef{
- Trait: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Method: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTraitUsePrecedence{
+ Ref: &ast.StmtTraitMethodRef{
+ Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Method: &ast.Identifier{Value: []byte("a")},
},
- Insteadof: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+ Insteadof: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
})
@@ -4284,12 +4283,12 @@ func TestPrinterPrintStmtTraitUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitUse{
- Traits: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+ p.Print(&ast.StmtTraitUse{
+ Traits: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
},
- TraitAdaptationList: &stmt.Nop{},
+ TraitAdaptationList: &ast.StmtNop{},
})
expected := `use Foo,Bar;`
@@ -4304,19 +4303,19 @@ func TestPrinterPrintStmtTraitAdaptations(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.TraitUse{
- Traits: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Bar"}}},
+ p.Print(&ast.StmtTraitUse{
+ Traits: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Bar")}}},
},
- TraitAdaptationList: &stmt.TraitAdaptationList{
- Adaptations: []node.Node{
- &stmt.TraitUseAlias{
- Ref: &stmt.TraitMethodRef{
- Trait: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Method: &node.Identifier{Value: "a"},
+ TraitAdaptationList: &ast.StmtTraitAdaptationList{
+ Adaptations: []ast.Vertex{
+ &ast.StmtTraitUseAlias{
+ Ref: &ast.StmtTraitMethodRef{
+ Trait: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Method: &ast.Identifier{Value: []byte("a")},
},
- Alias: &node.Identifier{Value: "b"},
+ Alias: &ast.Identifier{Value: []byte("b")},
},
},
},
@@ -4334,17 +4333,17 @@ func TestPrinterPrintTrait(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Trait{
- TraitName: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Stmts: []node.Node{
- &stmt.ClassMethod{
- Modifiers: []node.Node{&node.Identifier{Value: "public"}},
- MethodName: &node.Identifier{Value: "foo"},
- Params: []node.Node{},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTrait{
+ TraitName: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Stmts: []ast.Vertex{
+ &ast.StmtClassMethod{
+ Modifiers: []ast.Vertex{&ast.Identifier{Value: []byte("public")}},
+ MethodName: &ast.Identifier{Value: []byte("foo")},
+ Params: []ast.Vertex{},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
@@ -4364,31 +4363,31 @@ func TestPrinterPrintStmtTry(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Try{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtTry{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
- Catches: []node.Node{
- &stmt.Catch{
- Types: []node.Node{
- &name.Name{Parts: []node.Node{&name.NamePart{Value: "Exception"}}},
- &name.FullyQualified{Parts: []node.Node{&name.NamePart{Value: "RuntimeException"}}},
+ Catches: []ast.Vertex{
+ &ast.StmtCatch{
+ Types: []ast.Vertex{
+ &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Exception")}}},
+ &ast.NameFullyQualified{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("RuntimeException")}}},
},
- Variable: &expr.Variable{
- VarName: &node.Identifier{Value: "e"},
+ Var: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("e")},
},
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
}},
},
},
},
- Finally: &stmt.Finally{
- Stmts: []node.Node{
- &stmt.Nop{},
+ Finally: &ast.StmtFinally{
+ Stmts: []ast.Vertex{
+ &ast.StmtNop{},
},
},
})
@@ -4405,13 +4404,13 @@ func TestPrinterPrintStmtUnset(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Unset{
- Vars: []node.Node{
- &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtUnset{
+ Vars: []ast.Vertex{
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- &expr.Variable{
- VarName: &node.Identifier{Value: "b"},
+ &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("b")},
},
},
})
@@ -4428,15 +4427,15 @@ func TestPrinterPrintStmtUseList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.UseList{
- UseType: &node.Identifier{Value: "function"},
- Uses: []node.Node{
- &stmt.Use{
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Alias: &node.Identifier{Value: "Bar"},
+ p.Print(&ast.StmtUseList{
+ UseType: &ast.Identifier{Value: []byte("function")},
+ Uses: []ast.Vertex{
+ &ast.StmtUse{
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Alias: &ast.Identifier{Value: []byte("Bar")},
},
- &stmt.Use{
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Baz"}}},
+ &ast.StmtUse{
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
},
})
@@ -4453,10 +4452,10 @@ func TestPrinterPrintUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.Use{
- UseType: &node.Identifier{Value: "function"},
- Use: &name.Name{Parts: []node.Node{&name.NamePart{Value: "Foo"}}},
- Alias: &node.Identifier{Value: "Bar"},
+ p.Print(&ast.StmtUse{
+ UseType: &ast.Identifier{Value: []byte("function")},
+ Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
+ Alias: &ast.Identifier{Value: []byte("Bar")},
})
expected := `function Foo as Bar`
@@ -4471,14 +4470,14 @@ func TestPrinterPrintWhileStmtList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
- p.Print(&stmt.While{
- Cond: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ p.Print(&ast.StmtWhile{
+ Cond: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
},
- Stmt: &stmt.StmtList{
- Stmts: []node.Node{
- &stmt.Expression{Expr: &expr.Variable{
- VarName: &node.Identifier{Value: "a"},
+ Stmt: &ast.StmtStmtList{
+ Stmts: []ast.Vertex{
+ &ast.StmtExpression{Expr: &ast.ExprVariable{
+ VarName: &ast.Identifier{Value: []byte("a")},
}},
},
},
diff --git a/pkg/token/position.go b/pkg/token/position.go
index 209ed9d..7032e5a 100644
--- a/pkg/token/position.go
+++ b/pkg/token/position.go
@@ -2,8 +2,6 @@ package token
type Position int
-type Collection map[Position][]Token
-
//go:generate stringer -type=Position -output ./position_string.go
const (
Start Position = iota
@@ -86,3 +84,14 @@ const (
OpenParenthesisToken
CloseParenthesisToken
)
+
+type Collection map[Position][]Token
+
+func (c Collection) IsEmpty() bool {
+ for _, v := range c {
+ if len(v) > 0 {
+ return false
+ }
+ }
+ return true
+}
diff --git a/printer/printer.go b/printer/printer.go
deleted file mode 100644
index 06ad2ae..0000000
--- a/printer/printer.go
+++ /dev/null
@@ -1,3267 +0,0 @@
-package printer
-
-import (
- "io"
- "strings"
-
- "github.com/z7zmey/php-parser/freefloating"
-
- "github.com/z7zmey/php-parser/node/stmt"
-
- "github.com/z7zmey/php-parser/node"
- "github.com/z7zmey/php-parser/node/expr"
- "github.com/z7zmey/php-parser/node/expr/assign"
- "github.com/z7zmey/php-parser/node/expr/binary"
- "github.com/z7zmey/php-parser/node/expr/cast"
- "github.com/z7zmey/php-parser/node/name"
- "github.com/z7zmey/php-parser/node/scalar"
-)
-
-type printerState int
-
-const (
- PhpState printerState = iota
- HtmlState
-)
-
-type Printer struct {
- w io.Writer
- s printerState
-}
-
-// NewPrinter - Constructor for Printer
-func NewPrinter(w io.Writer) *Printer {
- return &Printer{
- w: w,
- }
-}
-
-func (p *Printer) SetState(s printerState) {
- p.s = s
-}
-
-func (p *Printer) Print(n node.Node) {
- _, isRoot := n.(*node.Root)
- _, isInlineHtml := n.(*stmt.InlineHtml)
- if p.s == HtmlState && !isInlineHtml && !isRoot {
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " 0 {
- io.WriteString(p.w, glue)
- }
-
- p.Print(n)
- }
-}
-
-func (p *Printer) printNodes(nn []node.Node) {
- for _, n := range nn {
- p.Print(n)
- }
-}
-
-func (p *Printer) printFreeFloating(n node.Node, pos freefloating.Position) {
- if n == nil {
- return
- }
-
- for _, m := range (*n.GetFreeFloating())[pos] {
- io.WriteString(p.w, m.Value)
- }
-}
-
-func (p *Printer) printNode(n node.Node) {
- switch n.(type) {
-
- // node
-
- case *node.Root:
- p.printNodeRoot(n)
- case *node.Identifier:
- p.printNodeIdentifier(n)
- case *node.Parameter:
- p.printNodeParameter(n)
- case *node.Nullable:
- p.printNodeNullable(n)
- case *node.Argument:
- p.printNodeArgument(n)
-
- // name
-
- case *name.NamePart:
- p.printNameNamePart(n)
- case *name.Name:
- p.printNameName(n)
- case *name.FullyQualified:
- p.printNameFullyQualified(n)
- case *name.Relative:
- p.printNameRelative(n)
-
- // scalar
-
- case *scalar.Lnumber:
- p.printScalarLNumber(n)
- case *scalar.Dnumber:
- p.printScalarDNumber(n)
- case *scalar.String:
- p.printScalarString(n)
- case *scalar.EncapsedStringPart:
- p.printScalarEncapsedStringPart(n)
- case *scalar.Encapsed:
- p.printScalarEncapsed(n)
- case *scalar.Heredoc:
- p.printScalarHeredoc(n)
- case *scalar.MagicConstant:
- p.printScalarMagicConstant(n)
-
- // assign
-
- case *assign.Assign:
- p.printAssign(n)
- case *assign.Reference:
- p.printAssignReference(n)
- case *assign.BitwiseAnd:
- p.printAssignBitwiseAnd(n)
- case *assign.BitwiseOr:
- p.printAssignBitwiseOr(n)
- case *assign.BitwiseXor:
- p.printAssignBitwiseXor(n)
- case *assign.Coalesce:
- p.printAssignCoalesce(n)
- case *assign.Concat:
- p.printAssignConcat(n)
- case *assign.Div:
- p.printAssignDiv(n)
- case *assign.Minus:
- p.printAssignMinus(n)
- case *assign.Mod:
- p.printAssignMod(n)
- case *assign.Mul:
- p.printAssignMul(n)
- case *assign.Plus:
- p.printAssignPlus(n)
- case *assign.Pow:
- p.printAssignPow(n)
- case *assign.ShiftLeft:
- p.printAssignShiftLeft(n)
- case *assign.ShiftRight:
- p.printAssignShiftRight(n)
-
- // binary
-
- case *binary.BitwiseAnd:
- p.printBinaryBitwiseAnd(n)
- case *binary.BitwiseOr:
- p.printBinaryBitwiseOr(n)
- case *binary.BitwiseXor:
- p.printBinaryBitwiseXor(n)
- case *binary.BooleanAnd:
- p.printBinaryBooleanAnd(n)
- case *binary.BooleanOr:
- p.printBinaryBooleanOr(n)
- case *binary.Coalesce:
- p.printBinaryCoalesce(n)
- case *binary.Concat:
- p.printBinaryConcat(n)
- case *binary.Div:
- p.printBinaryDiv(n)
- case *binary.Equal:
- p.printBinaryEqual(n)
- case *binary.GreaterOrEqual:
- p.printBinaryGreaterOrEqual(n)
- case *binary.Greater:
- p.printBinaryGreater(n)
- case *binary.Identical:
- p.printBinaryIdentical(n)
- case *binary.LogicalAnd:
- p.printBinaryLogicalAnd(n)
- case *binary.LogicalOr:
- p.printBinaryLogicalOr(n)
- case *binary.LogicalXor:
- p.printBinaryLogicalXor(n)
- case *binary.Minus:
- p.printBinaryMinus(n)
- case *binary.Mod:
- p.printBinaryMod(n)
- case *binary.Mul:
- p.printBinaryMul(n)
- case *binary.NotEqual:
- p.printBinaryNotEqual(n)
- case *binary.NotIdentical:
- p.printBinaryNotIdentical(n)
- case *binary.Plus:
- p.printBinaryPlus(n)
- case *binary.Pow:
- p.printBinaryPow(n)
- case *binary.ShiftLeft:
- p.printBinaryShiftLeft(n)
- case *binary.ShiftRight:
- p.printBinaryShiftRight(n)
- case *binary.SmallerOrEqual:
- p.printBinarySmallerOrEqual(n)
- case *binary.Smaller:
- p.printBinarySmaller(n)
- case *binary.Spaceship:
- p.printBinarySpaceship(n)
-
- // cast
-
- case *cast.Array:
- p.printArray(n)
- case *cast.Bool:
- p.printBool(n)
- case *cast.Double:
- p.printDouble(n)
- case *cast.Int:
- p.printInt(n)
- case *cast.Object:
- p.printObject(n)
- case *cast.String:
- p.printString(n)
- case *cast.Unset:
- p.printUnset(n)
-
- // expr
-
- case *expr.ArrayDimFetch:
- p.printExprArrayDimFetch(n)
- case *expr.ArrayItem:
- p.printExprArrayItem(n)
- case *expr.Array:
- p.printExprArray(n)
- case *expr.ArrowFunction:
- p.printExprArrowFunction(n)
- case *expr.BitwiseNot:
- p.printExprBitwiseNot(n)
- case *expr.BooleanNot:
- p.printExprBooleanNot(n)
- case *expr.ClassConstFetch:
- p.printExprClassConstFetch(n)
- case *expr.Clone:
- p.printExprClone(n)
- case *expr.ClosureUse:
- p.printExprClosureUse(n)
- case *expr.Closure:
- p.printExprClosure(n)
- case *expr.ConstFetch:
- p.printExprConstFetch(n)
- case *expr.Empty:
- p.printExprEmpty(n)
- case *expr.ErrorSuppress:
- p.printExprErrorSuppress(n)
- case *expr.Eval:
- p.printExprEval(n)
- case *expr.Exit:
- p.printExprExit(n)
- case *expr.FunctionCall:
- p.printExprFunctionCall(n)
- case *expr.Include:
- p.printExprInclude(n)
- case *expr.IncludeOnce:
- p.printExprIncludeOnce(n)
- case *expr.InstanceOf:
- p.printExprInstanceOf(n)
- case *expr.Isset:
- p.printExprIsset(n)
- case *expr.List:
- p.printExprList(n)
- case *expr.MethodCall:
- p.printExprMethodCall(n)
- case *expr.New:
- p.printExprNew(n)
- case *expr.PostDec:
- p.printExprPostDec(n)
- case *expr.PostInc:
- p.printExprPostInc(n)
- case *expr.PreDec:
- p.printExprPreDec(n)
- case *expr.PreInc:
- p.printExprPreInc(n)
- case *expr.Print:
- p.printExprPrint(n)
- case *expr.PropertyFetch:
- p.printExprPropertyFetch(n)
- case *expr.Reference:
- p.printExprReference(n)
- case *expr.Require:
- p.printExprRequire(n)
- case *expr.RequireOnce:
- p.printExprRequireOnce(n)
- case *expr.ShellExec:
- p.printExprShellExec(n)
- case *expr.ShortArray:
- p.printExprShortArray(n)
- case *expr.ShortList:
- p.printExprShortList(n)
- case *expr.StaticCall:
- p.printExprStaticCall(n)
- case *expr.StaticPropertyFetch:
- p.printExprStaticPropertyFetch(n)
- case *expr.Ternary:
- p.printExprTernary(n)
- case *expr.UnaryMinus:
- p.printExprUnaryMinus(n)
- case *expr.UnaryPlus:
- p.printExprUnaryPlus(n)
- case *expr.Variable:
- p.printExprVariable(n)
- case *expr.YieldFrom:
- p.printExprYieldFrom(n)
- case *expr.Yield:
- p.printExprYield(n)
-
- // stmt
-
- case *stmt.AltElseIf:
- p.printStmtAltElseIf(n)
- case *stmt.AltElse:
- p.printStmtAltElse(n)
- case *stmt.AltFor:
- p.printStmtAltFor(n)
- case *stmt.AltForeach:
- p.printStmtAltForeach(n)
- case *stmt.AltIf:
- p.printStmtAltIf(n)
- case *stmt.AltSwitch:
- p.printStmtAltSwitch(n)
- case *stmt.AltWhile:
- p.printStmtAltWhile(n)
- case *stmt.Break:
- p.printStmtBreak(n)
- case *stmt.Case:
- p.printStmtCase(n)
- case *stmt.Catch:
- p.printStmtCatch(n)
- case *stmt.ClassMethod:
- p.printStmtClassMethod(n)
- case *stmt.Class:
- p.printStmtClass(n)
- case *stmt.ClassConstList:
- p.printStmtClassConstList(n)
- case *stmt.ConstList:
- p.printStmtConstList(n)
- case *stmt.Constant:
- p.printStmtConstant(n)
- case *stmt.Continue:
- p.printStmtContinue(n)
- case *stmt.Declare:
- p.printStmtDeclare(n)
- case *stmt.Default:
- p.printStmtDefault(n)
- case *stmt.Do:
- p.printStmtDo(n)
- case *stmt.Echo:
- p.printStmtEcho(n)
- case *stmt.ElseIf:
- p.printStmtElseif(n)
- case *stmt.Else:
- p.printStmtElse(n)
- case *stmt.Expression:
- p.printStmtExpression(n)
- case *stmt.Finally:
- p.printStmtFinally(n)
- case *stmt.For:
- p.printStmtFor(n)
- case *stmt.Foreach:
- p.printStmtForeach(n)
- case *stmt.Function:
- p.printStmtFunction(n)
- case *stmt.Global:
- p.printStmtGlobal(n)
- case *stmt.Goto:
- p.printStmtGoto(n)
- case *stmt.GroupUse:
- p.printStmtGroupUse(n)
- case *stmt.HaltCompiler:
- p.printStmtHaltCompiler(n)
- case *stmt.If:
- p.printStmtIf(n)
- case *stmt.InlineHtml:
- p.printStmtInlineHTML(n)
- case *stmt.Interface:
- p.printStmtInterface(n)
- case *stmt.Label:
- p.printStmtLabel(n)
- case *stmt.Namespace:
- p.printStmtNamespace(n)
- case *stmt.Nop:
- p.printStmtNop(n)
- case *stmt.PropertyList:
- p.printStmtPropertyList(n)
- case *stmt.Property:
- p.printStmtProperty(n)
- case *stmt.Return:
- p.printStmtReturn(n)
- case *stmt.StaticVar:
- p.printStmtStaticVar(n)
- case *stmt.Static:
- p.printStmtStatic(n)
- case *stmt.StmtList:
- p.printStmtStmtList(n)
- case *stmt.Switch:
- p.printStmtSwitch(n)
- case *stmt.Throw:
- p.printStmtThrow(n)
- case *stmt.TraitAdaptationList:
- p.printStmtTraitAdaptationList(n)
- case *stmt.TraitMethodRef:
- p.printStmtTraitMethodRef(n)
- case *stmt.TraitUseAlias:
- p.printStmtTraitUseAlias(n)
- case *stmt.TraitUsePrecedence:
- p.printStmtTraitUsePrecedence(n)
- case *stmt.TraitUse:
- p.printStmtTraitUse(n)
- case *stmt.Trait:
- p.printStmtTrait(n)
- case *stmt.Try:
- p.printStmtTry(n)
- case *stmt.Unset:
- p.printStmtUnset(n)
- case *stmt.UseList:
- p.printStmtUseList(n)
- case *stmt.Use:
- p.printStmtUse(n)
- case *stmt.While:
- p.printStmtWhile(n)
- }
-}
-
-// node
-
-func (p *Printer) printNodeRoot(n node.Node) {
- nn := n.(*node.Root)
- p.SetState(HtmlState)
- p.printFreeFloating(nn, freefloating.Start)
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeIdentifier(n node.Node) {
- nn := n.(*node.Identifier)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, nn.Value)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeParameter(n node.Node) {
- nn := n.(*node.Parameter)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.VariableType != nil {
- p.Print(nn.VariableType)
- }
- p.printFreeFloating(nn, freefloating.OptionalType)
-
- if nn.ByRef {
- io.WriteString(p.w, "&")
- }
- p.printFreeFloating(nn, freefloating.Ampersand)
-
- if nn.Variadic {
- io.WriteString(p.w, "...")
- }
- p.printFreeFloating(nn, freefloating.Variadic)
-
- p.Print(nn.Variable)
-
- if nn.DefaultValue != nil {
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "=")
- p.Print(nn.DefaultValue)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeNullable(n node.Node) {
- nn := n.(*node.Nullable)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "?")
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNodeArgument(n node.Node) {
- nn := n.(*node.Argument)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.IsReference {
- io.WriteString(p.w, "&")
- }
- p.printFreeFloating(nn, freefloating.Ampersand)
-
- if nn.Variadic {
- io.WriteString(p.w, "...")
- }
- p.printFreeFloating(nn, freefloating.Variadic)
-
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// name
-
-func (p *Printer) printNameNamePart(n node.Node) {
- nn := n.(*name.NamePart)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, nn.Value)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNameName(n node.Node) {
- nn := n.(*name.Name)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.joinPrint("\\", nn.Parts)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNameFullyQualified(n node.Node) {
- nn := n.(*name.FullyQualified)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "\\")
- p.joinPrint("\\", nn.Parts)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printNameRelative(n node.Node) {
- nn := n.(*name.Relative)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "namespace")
- p.printFreeFloating(nn, freefloating.Namespace)
-
- for _, part := range nn.Parts {
- io.WriteString(p.w, "\\")
- p.Print(part)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// scalar
-
-func (p *Printer) printScalarLNumber(n node.Node) {
- nn := n.(*scalar.Lnumber)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, nn.Value)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarDNumber(n node.Node) {
- nn := n.(*scalar.Dnumber)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, nn.Value)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarString(n node.Node) {
- nn := n.(*scalar.String)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, nn.Value)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarEncapsedStringPart(n node.Node) {
- nn := n.(*scalar.EncapsedStringPart)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, nn.Value)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarEncapsed(n node.Node) {
- nn := n.(*scalar.Encapsed)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "\"")
- for _, part := range nn.Parts {
- switch part.(type) {
- case *expr.ArrayDimFetch:
- s := (*part.GetFreeFloating())[freefloating.Start]
- if len(s) > 0 && s[0].Value == "${" {
- p.printExprArrayDimFetchWithoutLeadingDollar(part)
- } else {
- p.Print(part)
- }
- case *expr.Variable:
- s := (*part.GetFreeFloating())[freefloating.Start]
- if len(s) > 0 && s[0].Value == "${" {
- p.printExprVariableWithoutLeadingDollar(part)
- } else {
- p.Print(part)
- }
- default:
- p.Print(part)
- }
- }
- io.WriteString(p.w, "\"")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarHeredoc(n node.Node) {
- nn := n.(*scalar.Heredoc)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, nn.Label)
-
- for _, part := range nn.Parts {
- switch part.(type) {
- case *expr.ArrayDimFetch:
- s := (*part.GetFreeFloating())[freefloating.Start]
- if len(s) > 0 && s[0].Value == "${" {
- p.printExprArrayDimFetchWithoutLeadingDollar(part)
- } else {
- p.Print(part)
- }
- case *expr.Variable:
- s := (*part.GetFreeFloating())[freefloating.Start]
- if len(s) > 0 && s[0].Value == "${" {
- p.printExprVariableWithoutLeadingDollar(part)
- } else {
- p.Print(part)
- }
- default:
- p.Print(part)
- }
- }
-
- io.WriteString(p.w, strings.Trim(nn.Label, "<\"'\n"))
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printScalarMagicConstant(n node.Node) {
- nn := n.(*scalar.MagicConstant)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, nn.Value)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// Assign
-
-func (p *Printer) printAssign(n node.Node) {
- nn := n.(*assign.Assign)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignReference(n node.Node) {
- nn := n.(*assign.Reference)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "=")
- p.printFreeFloating(nn, freefloating.Equal)
- io.WriteString(p.w, "&")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignBitwiseAnd(n node.Node) {
- nn := n.(*assign.BitwiseAnd)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "&")
- io.WriteString(p.w, "=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignBitwiseOr(n node.Node) {
- nn := n.(*assign.BitwiseOr)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "|=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignBitwiseXor(n node.Node) {
- nn := n.(*assign.BitwiseXor)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "^=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignCoalesce(n node.Node) {
- nn := n.(*assign.Coalesce)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "??=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignConcat(n node.Node) {
- nn := n.(*assign.Concat)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, ".=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignDiv(n node.Node) {
- nn := n.(*assign.Div)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "/=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignMinus(n node.Node) {
- nn := n.(*assign.Minus)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "-=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignMod(n node.Node) {
- nn := n.(*assign.Mod)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "%=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignMul(n node.Node) {
- nn := n.(*assign.Mul)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "*=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignPlus(n node.Node) {
- nn := n.(*assign.Plus)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "+=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignPow(n node.Node) {
- nn := n.(*assign.Pow)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "**=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignShiftLeft(n node.Node) {
- nn := n.(*assign.ShiftLeft)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "<<=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printAssignShiftRight(n node.Node) {
- nn := n.(*assign.ShiftRight)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, ">>=")
- p.Print(nn.Expression)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// binary
-
-func (p *Printer) printBinaryBitwiseAnd(n node.Node) {
- nn := n.(*binary.BitwiseAnd)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "&")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBitwiseOr(n node.Node) {
- nn := n.(*binary.BitwiseOr)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "|")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBitwiseXor(n node.Node) {
- nn := n.(*binary.BitwiseXor)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "^")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBooleanAnd(n node.Node) {
- nn := n.(*binary.BooleanAnd)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "&&")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryBooleanOr(n node.Node) {
- nn := n.(*binary.BooleanOr)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "||")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryCoalesce(n node.Node) {
- nn := n.(*binary.Coalesce)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "??")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryConcat(n node.Node) {
- nn := n.(*binary.Concat)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ".")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryDiv(n node.Node) {
- nn := n.(*binary.Div)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "/")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryEqual(n node.Node) {
- nn := n.(*binary.Equal)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "==")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryGreaterOrEqual(n node.Node) {
- nn := n.(*binary.GreaterOrEqual)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ">=")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryGreater(n node.Node) {
- nn := n.(*binary.Greater)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ">")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryIdentical(n node.Node) {
- nn := n.(*binary.Identical)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "===")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryLogicalAnd(n node.Node) {
- nn := n.(*binary.LogicalAnd)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "and")
- if nn.Right.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryLogicalOr(n node.Node) {
- nn := n.(*binary.LogicalOr)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "or")
- if nn.Right.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryLogicalXor(n node.Node) {
- nn := n.(*binary.LogicalXor)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "xor")
- if nn.Right.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryMinus(n node.Node) {
- nn := n.(*binary.Minus)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "-")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryMod(n node.Node) {
- nn := n.(*binary.Mod)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "%")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryMul(n node.Node) {
- nn := n.(*binary.Mul)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "*")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryNotEqual(n node.Node) {
- nn := n.(*binary.NotEqual)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- p.printFreeFloating(nn, freefloating.Equal)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "!=")
- }
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryNotIdentical(n node.Node) {
- nn := n.(*binary.NotIdentical)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "!==")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryPlus(n node.Node) {
- nn := n.(*binary.Plus)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "+")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryPow(n node.Node) {
- nn := n.(*binary.Pow)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "**")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryShiftLeft(n node.Node) {
- nn := n.(*binary.ShiftLeft)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "<<")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinaryShiftRight(n node.Node) {
- nn := n.(*binary.ShiftRight)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ">>")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinarySmallerOrEqual(n node.Node) {
- nn := n.(*binary.SmallerOrEqual)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "<=")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinarySmaller(n node.Node) {
- nn := n.(*binary.Smaller)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "<")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBinarySpaceship(n node.Node) {
- nn := n.(*binary.Spaceship)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Left)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "<=>")
- p.Print(nn.Right)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// cast
-
-func (p *Printer) printArray(n node.Node) {
- nn := n.(*cast.Array)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(array)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printBool(n node.Node) {
- nn := n.(*cast.Bool)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(boolean)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printDouble(n node.Node) {
- nn := n.(*cast.Double)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(float)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printInt(n node.Node) {
- nn := n.(*cast.Int)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(integer)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printObject(n node.Node) {
- nn := n.(*cast.Object)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(object)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printString(n node.Node) {
- nn := n.(*cast.String)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(string)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printUnset(n node.Node) {
- nn := n.(*cast.Unset)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Cast)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "(unset)")
- }
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// expr
-
-func (p *Printer) printExprArrayDimFetch(n node.Node) {
- nn := n.(*expr.ArrayDimFetch)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "[")
- }
- p.Print(nn.Dim)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "]")
- }
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArrayDimFetchWithoutLeadingDollar(n node.Node) {
- nn := n.(*expr.ArrayDimFetch)
- p.printFreeFloating(nn, freefloating.Start)
- p.printExprVariableWithoutLeadingDollar(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "[")
- }
- p.Print(nn.Dim)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "]")
- }
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArrayItem(n node.Node) {
- nn := n.(*expr.ArrayItem)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Unpack {
- io.WriteString(p.w, "...")
- }
-
- if nn.Key != nil {
- p.Print(nn.Key)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "=>")
- }
-
- p.Print(nn.Val)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArray(n node.Node) {
- nn := n.(*expr.Array)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "array")
- p.printFreeFloating(nn, freefloating.Array)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Items)
- p.printFreeFloating(nn, freefloating.ArrayPairList)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprArrowFunction(n node.Node) {
- nn := n.(*expr.ArrowFunction)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Static {
- io.WriteString(p.w, "static")
- }
- p.printFreeFloating(nn, freefloating.Static)
- if nn.Static && n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- io.WriteString(p.w, "fn")
- p.printFreeFloating(nn, freefloating.Function)
-
- if nn.ReturnsRef {
- io.WriteString(p.w, "&")
- }
- p.printFreeFloating(nn, freefloating.Ampersand)
-
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Params)
- p.printFreeFloating(nn, freefloating.ParameterList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Params)
-
- if nn.ReturnType != nil {
- io.WriteString(p.w, ":")
- p.Print(nn.ReturnType)
- }
- p.printFreeFloating(nn, freefloating.ReturnType)
-
- io.WriteString(p.w, "=>")
-
- p.printNode(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprBitwiseNot(n node.Node) {
- nn := n.(*expr.BitwiseNot)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "~")
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprBooleanNot(n node.Node) {
- nn := n.(*expr.BooleanNot)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "!")
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClassConstFetch(n node.Node) {
- nn := n.(*expr.ClassConstFetch)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Class)
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "::")
- p.Print(nn.ConstantName)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClone(n node.Node) {
- nn := n.(*expr.Clone)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "clone")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClosureUse(n node.Node) {
- nn := n.(*expr.ClosureUse)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "use")
- p.printFreeFloating(nn, freefloating.Use)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Uses)
- p.printFreeFloating(nn, freefloating.LexicalVarList)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprClosure(n node.Node) {
- nn := n.(*expr.Closure)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Static {
- io.WriteString(p.w, "static")
- }
- p.printFreeFloating(nn, freefloating.Static)
- if nn.Static && n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- io.WriteString(p.w, "function")
- p.printFreeFloating(nn, freefloating.Function)
-
- if nn.ReturnsRef {
- io.WriteString(p.w, "&")
- }
- p.printFreeFloating(nn, freefloating.Ampersand)
-
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Params)
- p.printFreeFloating(nn, freefloating.ParameterList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Params)
-
- if nn.ClosureUse != nil {
- p.Print(nn.ClosureUse)
- }
- p.printFreeFloating(nn, freefloating.LexicalVars)
-
- if nn.ReturnType != nil {
- io.WriteString(p.w, ":")
- p.Print(nn.ReturnType)
- }
- p.printFreeFloating(nn, freefloating.ReturnType)
-
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprConstFetch(n node.Node) {
- nn := n.(*expr.ConstFetch)
- p.printFreeFloating(nn, freefloating.Start)
- p.Print(nn.Constant)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprEmpty(n node.Node) {
- nn := n.(*expr.Empty)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "empty")
- p.printFreeFloating(nn, freefloating.Empty)
- io.WriteString(p.w, "(")
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprErrorSuppress(n node.Node) {
- nn := n.(*expr.ErrorSuppress)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "@")
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprEval(n node.Node) {
- nn := n.(*expr.Eval)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "eval")
- p.printFreeFloating(nn, freefloating.Eval)
- io.WriteString(p.w, "(")
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprExit(n node.Node) {
- nn := n.(*expr.Exit)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Die {
- io.WriteString(p.w, "die")
- } else {
- io.WriteString(p.w, "exit")
- }
- p.printFreeFloating(nn, freefloating.Exit)
-
- if nn.Expr != nil && nn.Expr.GetFreeFloating().IsEmpty() && nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprFunctionCall(n node.Node) {
- nn := n.(*expr.FunctionCall)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Function)
-
- p.printFreeFloating(nn.ArgumentList, freefloating.Start)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.ArgumentList.Arguments)
- p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn.ArgumentList, freefloating.End)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprInclude(n node.Node) {
- nn := n.(*expr.Include)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "include")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprIncludeOnce(n node.Node) {
- nn := n.(*expr.IncludeOnce)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "include_once")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprInstanceOf(n node.Node) {
- nn := n.(*expr.InstanceOf)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- io.WriteString(p.w, "instanceof")
-
- if nn.Class.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Class)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprIsset(n node.Node) {
- nn := n.(*expr.Isset)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "isset")
- p.printFreeFloating(nn, freefloating.Isset)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Variables)
- p.printFreeFloating(nn, freefloating.VarList)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprList(n node.Node) {
- nn := n.(*expr.List)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "list")
- p.printFreeFloating(nn, freefloating.List)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Items)
- p.printFreeFloating(nn, freefloating.ArrayPairList)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprMethodCall(n node.Node) {
- nn := n.(*expr.MethodCall)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "->")
- p.Print(nn.Method)
-
- p.printFreeFloating(nn.ArgumentList, freefloating.Start)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.ArgumentList.Arguments)
- p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn.ArgumentList, freefloating.End)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprNew(n node.Node) {
- nn := n.(*expr.New)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "new")
- if nn.Class.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Class)
-
- if nn.ArgumentList != nil {
- p.printFreeFloating(nn.ArgumentList, freefloating.Start)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.ArgumentList.Arguments)
- p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn.ArgumentList, freefloating.End)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPostDec(n node.Node) {
- nn := n.(*expr.PostDec)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "--")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPostInc(n node.Node) {
- nn := n.(*expr.PostInc)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "++")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPreDec(n node.Node) {
- nn := n.(*expr.PreDec)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "--")
- p.Print(nn.Variable)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPreInc(n node.Node) {
- nn := n.(*expr.PreInc)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "++")
- p.Print(nn.Variable)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPrint(n node.Node) {
- nn := n.(*expr.Print)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "print")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprPropertyFetch(n node.Node) {
- nn := n.(*expr.PropertyFetch)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "->")
- p.Print(nn.Property)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprReference(n node.Node) {
- nn := n.(*expr.Reference)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "&")
- p.Print(nn.Variable)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprRequire(n node.Node) {
- nn := n.(*expr.Require)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "require")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprRequireOnce(n node.Node) {
- nn := n.(*expr.RequireOnce)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "require_once")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprShellExec(n node.Node) {
- nn := n.(*expr.ShellExec)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "`")
- p.joinPrint("", nn.Parts)
- io.WriteString(p.w, "`")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprShortArray(n node.Node) {
- nn := n.(*expr.ShortArray)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "[")
- p.joinPrint(",", nn.Items)
- p.printFreeFloating(nn, freefloating.ArrayPairList)
- io.WriteString(p.w, "]")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprShortList(n node.Node) {
- nn := n.(*expr.ShortList)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "[")
- p.joinPrint(",", nn.Items)
- p.printFreeFloating(nn, freefloating.ArrayPairList)
- io.WriteString(p.w, "]")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprStaticCall(n node.Node) {
- nn := n.(*expr.StaticCall)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Class)
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "::")
- p.Print(nn.Call)
-
- p.printFreeFloating(nn.ArgumentList, freefloating.Start)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.ArgumentList.Arguments)
- p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn.ArgumentList, freefloating.End)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprStaticPropertyFetch(n node.Node) {
- nn := n.(*expr.StaticPropertyFetch)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Class)
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "::")
- p.Print(nn.Property)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprTernary(n node.Node) {
- nn := n.(*expr.Ternary)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Condition)
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, "?")
-
- if nn.IfTrue != nil {
- p.Print(nn.IfTrue)
- }
- p.printFreeFloating(nn, freefloating.True)
-
- io.WriteString(p.w, ":")
- p.Print(nn.IfFalse)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprUnaryMinus(n node.Node) {
- nn := n.(*expr.UnaryMinus)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "-")
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprUnaryPlus(n node.Node) {
- nn := n.(*expr.UnaryPlus)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "+")
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprVariable(n node.Node) {
- nn := n.(*expr.Variable)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.printFreeFloating(nn, freefloating.Dollar)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "$")
- }
-
- p.Print(nn.VarName)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprVariableWithoutLeadingDollar(n node.Node) {
- nn := n.(*expr.Variable)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.VarName)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprYieldFrom(n node.Node) {
- nn := n.(*expr.YieldFrom)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "yield from")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printExprYield(n node.Node) {
- nn := n.(*expr.Yield)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "yield")
-
- if nn.Key != nil {
- if nn.Key.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Key)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, "=>")
- } else {
- if nn.Value.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.Print(nn.Value)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-// smtm
-
-func (p *Printer) printStmtAltElseIf(n node.Node) {
- nn := n.(*stmt.AltElseIf)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "elseif")
- p.printFreeFloating(nn, freefloating.ElseIf)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, ":")
-
- if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
- p.printNodes(s)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltElse(n node.Node) {
- nn := n.(*stmt.AltElse)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "else")
- p.printFreeFloating(nn, freefloating.Else)
- io.WriteString(p.w, ":")
-
- if s := nn.Stmt.(*stmt.StmtList).Stmts; len(s) > 0 {
- p.printNodes(s)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltFor(n node.Node) {
- nn := n.(*stmt.AltFor)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "for")
- p.printFreeFloating(nn, freefloating.For)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Init)
- p.printFreeFloating(nn, freefloating.InitExpr)
- io.WriteString(p.w, ";")
- p.joinPrint(",", nn.Cond)
- p.printFreeFloating(nn, freefloating.CondExpr)
- io.WriteString(p.w, ";")
- p.joinPrint(",", nn.Loop)
- p.printFreeFloating(nn, freefloating.IncExpr)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, ":")
-
- s := nn.Stmt.(*stmt.StmtList)
- p.printNodes(s.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
-
- io.WriteString(p.w, "endfor")
- p.printFreeFloating(nn, freefloating.AltEnd)
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltForeach(n node.Node) {
- nn := n.(*stmt.AltForeach)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "foreach")
- p.printFreeFloating(nn, freefloating.Foreach)
- io.WriteString(p.w, "(")
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "as")
-
- if nn.Key != nil {
- if nn.Key.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Key)
- p.printFreeFloating(nn, freefloating.Key)
- io.WriteString(p.w, "=>")
- } else {
- if nn.Variable.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
-
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
-
- io.WriteString(p.w, ":")
- s := nn.Stmt.(*stmt.StmtList)
- p.printNodes(s.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
-
- io.WriteString(p.w, "endforeach")
- p.printFreeFloating(nn, freefloating.AltEnd)
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltIf(n node.Node) {
- nn := n.(*stmt.AltIf)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "if")
- p.printFreeFloating(nn, freefloating.If)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, ":")
-
- s := nn.Stmt.(*stmt.StmtList)
- p.printNodes(s.Stmts)
-
- for _, elseif := range nn.ElseIf {
- p.Print(elseif)
- }
-
- if nn.Else != nil {
- p.Print(nn.Else)
- }
-
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "endif")
- p.printFreeFloating(nn, freefloating.AltEnd)
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltSwitch(n node.Node) {
- nn := n.(*stmt.AltSwitch)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "switch")
- p.printFreeFloating(nn, freefloating.Switch)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, ":")
-
- p.printFreeFloating(nn.CaseList, freefloating.Start)
- p.printFreeFloating(nn.CaseList, freefloating.CaseListStart)
- p.printNodes(nn.CaseList.Cases)
- p.printFreeFloating(nn.CaseList, freefloating.CaseListEnd)
- p.printFreeFloating(nn.CaseList, freefloating.End)
-
- io.WriteString(p.w, "endswitch")
- p.printFreeFloating(nn, freefloating.AltEnd)
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtAltWhile(n node.Node) {
- nn := n.(*stmt.AltWhile)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "while")
- p.printFreeFloating(nn, freefloating.While)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, ":")
-
- s := nn.Stmt.(*stmt.StmtList)
- p.printNodes(s.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
-
- io.WriteString(p.w, "endwhile")
- p.printFreeFloating(nn, freefloating.AltEnd)
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtBreak(n node.Node) {
- nn := n.(*stmt.Break)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "break")
- if nn.Expr != nil {
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- }
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtCase(n node.Node) {
- nn := n.(*stmt.Case)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "case")
- if nn.Cond.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- p.printFreeFloating(nn, freefloating.CaseSeparator)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ":")
- }
-
- if len(nn.Stmts) > 0 {
- p.printNodes(nn.Stmts)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtCatch(n node.Node) {
- nn := n.(*stmt.Catch)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "catch")
- p.printFreeFloating(nn, freefloating.Catch)
- io.WriteString(p.w, "(")
- p.joinPrint("|", nn.Types)
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtClassMethod(n node.Node) {
- nn := n.(*stmt.ClassMethod)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Modifiers != nil {
- for k, m := range nn.Modifiers {
- if k > 0 && m.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(m)
- }
-
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
- p.printFreeFloating(nn, freefloating.ModifierList)
- io.WriteString(p.w, "function")
- p.printFreeFloating(nn, freefloating.Function)
-
- if nn.ReturnsRef {
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "&")
- p.printFreeFloating(nn, freefloating.Ampersand)
- } else {
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.Print(nn.MethodName)
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Params)
- p.printFreeFloating(nn, freefloating.ParameterList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Params)
-
- if nn.ReturnType != nil {
- io.WriteString(p.w, ":")
- p.Print(nn.ReturnType)
- }
-
- p.Print(nn.Stmt)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtClass(n node.Node) {
- nn := n.(*stmt.Class)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Modifiers != nil {
- for k, m := range nn.Modifiers {
- if k > 0 && m.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(m)
- }
-
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
- p.printFreeFloating(nn, freefloating.ModifierList)
- io.WriteString(p.w, "class")
- p.printFreeFloating(nn, freefloating.Class)
-
- if nn.ClassName != nil {
- if nn.ClassName.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.ClassName)
- }
-
- if nn.ArgumentList != nil {
- p.printFreeFloating(nn.ArgumentList, freefloating.Start)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.ArgumentList.Arguments)
- p.printFreeFloating(nn.ArgumentList, freefloating.ArgumentList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn.ArgumentList, freefloating.End)
- }
-
- if nn.Extends != nil {
- p.printFreeFloating(nn.Extends, freefloating.Start)
- if nn.Extends.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "extends")
- if nn.Extends.ClassName.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Extends.ClassName)
- }
-
- if nn.Implements != nil {
- p.printFreeFloating(nn.Implements, freefloating.Start)
- if nn.Implements.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "implements")
- if nn.Implements.InterfaceNames[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Implements.InterfaceNames)
- }
-
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtClassConstList(n node.Node) {
- nn := n.(*stmt.ClassConstList)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Modifiers != nil {
- for k, m := range nn.Modifiers {
- if k > 0 && m.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(m)
- }
-
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
- p.printFreeFloating(nn, freefloating.ModifierList)
- io.WriteString(p.w, "const")
-
- if nn.Consts[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Consts)
- p.printFreeFloating(nn, freefloating.ConstList)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtConstList(n node.Node) {
- nn := n.(*stmt.ConstList)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "const")
-
- if nn.Consts[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Consts)
- p.printFreeFloating(nn, freefloating.Stmts)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtConstant(n node.Node) {
- nn := n.(*stmt.Constant)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.ConstantName)
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "=")
- p.Print(nn.Expr)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtContinue(n node.Node) {
- nn := n.(*stmt.Continue)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "continue")
-
- if nn.Expr != nil {
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- }
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtDeclare(n node.Node) {
- nn := n.(*stmt.Declare)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "declare")
- p.printFreeFloating(nn, freefloating.Declare)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Consts)
- p.printFreeFloating(nn, freefloating.ConstList)
- io.WriteString(p.w, ")")
-
- if nn.Alt {
- p.printFreeFloating(nn, freefloating.Cond)
- io.WriteString(p.w, ":")
-
- s := nn.Stmt.(*stmt.StmtList)
- p.printNodes(s.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
-
- io.WriteString(p.w, "enddeclare")
- p.printFreeFloating(nn, freefloating.AltEnd)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
- } else {
- p.Print(nn.Stmt)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtDefault(n node.Node) {
- nn := n.(*stmt.Default)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "default")
- p.printFreeFloating(nn, freefloating.Default)
- p.printFreeFloating(nn, freefloating.CaseSeparator)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ":")
- }
-
- if len(nn.Stmts) > 0 {
- p.printNodes(nn.Stmts)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtDo(n node.Node) {
- nn := n.(*stmt.Do)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "do")
-
- if _, ok := nn.Stmt.(*stmt.StmtList); !ok {
- if nn.Stmt.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.Print(nn.Stmt)
- p.printFreeFloating(nn, freefloating.Stmts)
-
- io.WriteString(p.w, "while")
- p.printFreeFloating(nn, freefloating.While)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Cond)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtEcho(n node.Node) {
- nn := n.(*stmt.Echo)
-
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "echo")
- }
- if nn.Exprs[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- p.printFreeFloating(nn, freefloating.Start)
- p.printFreeFloating(nn, freefloating.Echo)
-
- p.joinPrint(",", nn.Exprs)
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtElseif(n node.Node) {
- nn := n.(*stmt.ElseIf)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "elseif")
- p.printFreeFloating(nn, freefloating.ElseIf)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
-
- p.Print(nn.Stmt)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtElse(n node.Node) {
- nn := n.(*stmt.Else)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "else")
-
- if _, ok := nn.Stmt.(*stmt.StmtList); !ok {
- if nn.Stmt.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.Print(nn.Stmt)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtExpression(n node.Node) {
- nn := n.(*stmt.Expression)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtFinally(n node.Node) {
- nn := n.(*stmt.Finally)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "finally")
- p.printFreeFloating(nn, freefloating.Finally)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtFor(n node.Node) {
- nn := n.(*stmt.For)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "for")
- p.printFreeFloating(nn, freefloating.For)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Init)
- p.printFreeFloating(nn, freefloating.InitExpr)
- io.WriteString(p.w, ";")
- p.joinPrint(",", nn.Cond)
- p.printFreeFloating(nn, freefloating.CondExpr)
- io.WriteString(p.w, ";")
- p.joinPrint(",", nn.Loop)
- p.printFreeFloating(nn, freefloating.IncExpr)
- io.WriteString(p.w, ")")
-
- p.Print(nn.Stmt)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtForeach(n node.Node) {
- nn := n.(*stmt.Foreach)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "foreach")
- p.printFreeFloating(nn, freefloating.Foreach)
- io.WriteString(p.w, "(")
-
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- io.WriteString(p.w, "as")
-
- if nn.Key != nil {
- if nn.Key.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Key)
- p.printFreeFloating(nn, freefloating.Key)
- io.WriteString(p.w, "=>")
- } else {
- if nn.Variable.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
- p.Print(nn.Variable)
- p.printFreeFloating(nn, freefloating.Var)
-
- io.WriteString(p.w, ")")
-
- p.Print(nn.Stmt)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtFunction(n node.Node) {
- nn := n.(*stmt.Function)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "function")
- p.printFreeFloating(nn, freefloating.Function)
-
- if nn.ReturnsRef {
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "&")
- } else {
- if nn.FunctionName.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.Print(nn.FunctionName)
- p.printFreeFloating(nn, freefloating.Name)
-
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Params)
- p.printFreeFloating(nn, freefloating.ParamList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.Params)
-
- if nn.ReturnType != nil {
- io.WriteString(p.w, ":")
- p.Print(nn.ReturnType)
- }
- p.printFreeFloating(nn, freefloating.ReturnType)
-
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtGlobal(n node.Node) {
- nn := n.(*stmt.Global)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "global")
- p.joinPrint(",", nn.Vars)
- p.printFreeFloating(nn, freefloating.VarList)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtGoto(n node.Node) {
- nn := n.(*stmt.Goto)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "goto")
- if nn.Label.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Label)
- p.printFreeFloating(nn, freefloating.Label)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtGroupUse(n node.Node) {
- nn := n.(*stmt.GroupUse)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "use")
- p.printFreeFloating(nn, freefloating.Use)
-
- if nn.UseType != nil {
- if nn.UseType.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.UseType)
- }
-
- if nn.Prefix.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Prefix)
- io.WriteString(p.w, "\\")
- p.printFreeFloating(nn, freefloating.Slash)
-
- io.WriteString(p.w, "{")
- p.joinPrint(",", nn.UseList)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
- p.printFreeFloating(nn, freefloating.UseDeclarationList)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtHaltCompiler(n node.Node) {
- nn := n.(*stmt.HaltCompiler)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "__halt_compiler")
- p.printFreeFloating(nn, freefloating.HaltCompiller)
- io.WriteString(p.w, "(")
- p.printFreeFloating(nn, freefloating.OpenParenthesisToken)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.CloseParenthesisToken)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtIf(n node.Node) {
- nn := n.(*stmt.If)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "if")
- p.printFreeFloating(n, freefloating.If)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(n, freefloating.Expr)
- io.WriteString(p.w, ")")
-
- p.Print(nn.Stmt)
-
- if nn.ElseIf != nil {
- p.printNodes(nn.ElseIf)
- }
-
- if nn.Else != nil {
- p.Print(nn.Else)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtInlineHTML(n node.Node) {
- nn := n.(*stmt.InlineHtml)
- p.printFreeFloating(nn, freefloating.Start)
-
- if p.s == PhpState && nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, "?>")
- }
- p.SetState(HtmlState)
-
- io.WriteString(p.w, nn.Value)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtInterface(n node.Node) {
- nn := n.(*stmt.Interface)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "interface")
-
- if nn.InterfaceName.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- p.Print(nn.InterfaceName)
-
- if nn.Extends != nil {
- p.printFreeFloating(nn.Extends, freefloating.Start)
- if nn.Extends.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "extends")
- if nn.Extends.InterfaceNames[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Extends.InterfaceNames)
- }
-
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtLabel(n node.Node) {
- nn := n.(*stmt.Label)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.LabelName)
- p.printFreeFloating(nn, freefloating.Label)
-
- io.WriteString(p.w, ":")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtNamespace(n node.Node) {
- nn := n.(*stmt.Namespace)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "namespace")
-
- if nn.NamespaceName != nil {
- if nn.NamespaceName.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.NamespaceName)
- }
-
- if nn.Stmts != nil {
- p.printFreeFloating(nn, freefloating.Namespace)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
- } else {
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtNop(n node.Node) {
- p.printFreeFloating(n, freefloating.Start)
- p.printFreeFloating(n, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
- p.printFreeFloating(n, freefloating.End)
-}
-
-func (p *Printer) printStmtPropertyList(n node.Node) {
- nn := n.(*stmt.PropertyList)
- p.printFreeFloating(nn, freefloating.Start)
-
- for k, m := range nn.Modifiers {
- if k > 0 && m.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(m)
- }
-
- if nn.Type != nil && nn.Type.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- p.Print(nn.Type)
-
- if nn.Properties[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- p.joinPrint(",", nn.Properties)
- p.printFreeFloating(n, freefloating.PropertyList)
-
- p.printFreeFloating(n, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtProperty(n node.Node) {
- nn := n.(*stmt.Property)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Variable)
-
- if nn.Expr != nil {
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "=")
- p.Print(nn.Expr)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtReturn(n node.Node) {
- nn := n.(*stmt.Return)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "return")
- if nn.Expr != nil && nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtStaticVar(n node.Node) {
- nn := n.(*stmt.StaticVar)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Variable)
-
- if nn.Expr != nil {
- p.printFreeFloating(nn, freefloating.Var)
- io.WriteString(p.w, "=")
- p.Print(nn.Expr)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtStatic(n node.Node) {
- nn := n.(*stmt.Static)
- p.printFreeFloating(nn, freefloating.Start)
- io.WriteString(p.w, "static")
-
- p.joinPrint(",", nn.Vars)
- p.printFreeFloating(nn, freefloating.VarList)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtStmtList(n node.Node) {
- nn := n.(*stmt.StmtList)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtSwitch(n node.Node) {
- nn := n.(*stmt.Switch)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "switch")
- p.printFreeFloating(nn, freefloating.Switch)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
-
- p.printFreeFloating(nn.CaseList, freefloating.Start)
- io.WriteString(p.w, "{")
- p.printFreeFloating(nn.CaseList, freefloating.CaseListStart)
- p.printNodes(nn.CaseList.Cases)
- p.printFreeFloating(nn.CaseList, freefloating.CaseListEnd)
- io.WriteString(p.w, "}")
- p.printFreeFloating(nn.CaseList, freefloating.End)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtThrow(n node.Node) {
- nn := n.(*stmt.Throw)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "throw")
- if nn.Expr.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Expr)
- p.printFreeFloating(nn, freefloating.Expr)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitAdaptationList(n node.Node) {
- nn := n.(*stmt.TraitAdaptationList)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "{")
- p.printNodes(nn.Adaptations)
- p.printFreeFloating(nn, freefloating.AdaptationList)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitMethodRef(n node.Node) {
- nn := n.(*stmt.TraitMethodRef)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.Trait != nil {
- p.Print(nn.Trait)
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "::")
- }
-
- p.Print(nn.Method)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitUseAlias(n node.Node) {
- nn := n.(*stmt.TraitUseAlias)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Ref)
- p.printFreeFloating(nn, freefloating.Ref)
-
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "as")
-
- if nn.Modifier != nil {
- if nn.Modifier.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Modifier)
- }
-
- if nn.Alias != nil {
- if nn.Alias.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Alias)
- }
- p.printFreeFloating(nn, freefloating.Alias)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitUsePrecedence(n node.Node) {
- nn := n.(*stmt.TraitUsePrecedence)
- p.printFreeFloating(nn, freefloating.Start)
-
- p.Print(nn.Ref)
- p.printFreeFloating(nn, freefloating.Ref)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
-
- io.WriteString(p.w, "insteadof")
- if nn.Insteadof[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Insteadof)
- p.printFreeFloating(nn, freefloating.NameList)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTraitUse(n node.Node) {
- nn := n.(*stmt.TraitUse)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "use")
- if nn.Traits[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Traits)
-
- p.Print(nn.TraitAdaptationList)
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTrait(n node.Node) {
- nn := n.(*stmt.Trait)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "trait")
- if nn.TraitName.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.TraitName)
-
- p.printFreeFloating(nn, freefloating.Name)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtTry(n node.Node) {
- nn := n.(*stmt.Try)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "try")
- p.printFreeFloating(nn, freefloating.Try)
- io.WriteString(p.w, "{")
- p.printNodes(nn.Stmts)
- p.printFreeFloating(nn, freefloating.Stmts)
- io.WriteString(p.w, "}")
-
- if nn.Catches != nil {
- p.printNodes(nn.Catches)
- }
-
- if nn.Finally != nil {
- p.Print(nn.Finally)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtUnset(n node.Node) {
- nn := n.(*stmt.Unset)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "unset")
- p.printFreeFloating(nn, freefloating.Unset)
- io.WriteString(p.w, "(")
- p.joinPrint(",", nn.Vars)
- p.printFreeFloating(nn, freefloating.VarList)
- io.WriteString(p.w, ")")
- p.printFreeFloating(nn, freefloating.CloseParenthesisToken)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if n.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtUseList(n node.Node) {
- nn := n.(*stmt.UseList)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "use")
-
- if nn.UseType != nil {
- if nn.UseType.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.UseType)
- }
-
- if nn.Uses[0].GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.joinPrint(",", nn.Uses)
- p.printFreeFloating(nn, freefloating.UseDeclarationList)
-
- p.printFreeFloating(nn, freefloating.SemiColon)
- if nn.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, ";")
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtUse(n node.Node) {
- nn := n.(*stmt.Use)
- p.printFreeFloating(nn, freefloating.Start)
-
- if nn.UseType != nil {
- p.Print(nn.UseType)
- if nn.UseType.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- }
-
- p.printFreeFloating(nn, freefloating.Slash)
-
- p.Print(nn.Use)
-
- if nn.Alias != nil {
- if nn.Alias.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- io.WriteString(p.w, "as")
- if nn.Alias.GetFreeFloating().IsEmpty() {
- io.WriteString(p.w, " ")
- }
- p.Print(nn.Alias)
- }
-
- p.printFreeFloating(nn, freefloating.End)
-}
-
-func (p *Printer) printStmtWhile(n node.Node) {
- nn := n.(*stmt.While)
- p.printFreeFloating(nn, freefloating.Start)
-
- io.WriteString(p.w, "while")
- p.printFreeFloating(nn, freefloating.While)
- io.WriteString(p.w, "(")
- p.Print(nn.Cond)
- p.printFreeFloating(nn, freefloating.Expr)
- io.WriteString(p.w, ")")
-
- p.Print(nn.Stmt)
-
- p.printFreeFloating(nn, freefloating.End)
-}