maride/php-parser
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[refactoring] update use ast structure

Browse Source
This commit is contained in:
Vadym Slizov 2020-08-03 21:22:53 +02:00
parent 88dfd32d9e
commit feebb017c4
21 changed files with 3610 additions and 2681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
internal/php5/parser_test.go
View File

@ -11442,7 +11442,7 @@ func TestStmtUse(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11451,8 +11451,17 @@ func TestStmtUse(t *testing.T) {
EndPos: 11,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 10,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11488,6 +11497,7 @@ func TestStmtUse(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -11510,7 +11520,7 @@ func TestStmtUse_FullyQualified(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11519,8 +11529,17 @@ func TestStmtUse_FullyQualified(t *testing.T) {
EndPos: 12,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 8,
EndPos: 11,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11556,6 +11575,7 @@ func TestStmtUse_FullyQualified(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -11578,7 +11598,7 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11587,8 +11607,17 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
EndPos: 19,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 8,
EndPos: 18,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11635,6 +11664,7 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -11657,7 +11687,7 @@ func TestStmtUse_List(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11666,8 +11696,17 @@ func TestStmtUse_List(t *testing.T) {
EndPos: 16,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 15,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11700,7 +11739,7 @@ func TestStmtUse_List(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11736,6 +11775,7 @@ func TestStmtUse_List(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -11758,7 +11798,7 @@ func TestStmtUse_ListAlias(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11767,8 +11807,17 @@ func TestStmtUse_ListAlias(t *testing.T) {
EndPos: 23,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 22,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11801,7 +11850,7 @@ func TestStmtUse_ListAlias(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11848,6 +11897,7 @@ func TestStmtUse_ListAlias(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -11870,7 +11920,7 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11879,7 +11929,16 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
EndPos: 26,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 25,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11890,8 +11949,17 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 16,
EndPos: 25,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11924,7 +11992,7 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11960,6 +12028,8 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -11982,7 +12052,7 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -11991,7 +12061,16 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
EndPos: 40,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 39,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12002,8 +12081,17 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 16,
EndPos: 39,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12047,7 +12135,7 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12094,6 +12182,8 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -12116,7 +12206,7 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12125,7 +12215,17 @@ func TestStmtUse_ListConstType(t *testing.T) {
EndPos: 23,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 22,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12136,8 +12236,17 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 13,
EndPos: 22,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12170,7 +12279,7 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12206,6 +12315,8 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)
@ -12228,7 +12339,7 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12237,7 +12348,16 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
EndPos: 37,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 36,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12248,8 +12368,17 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 13,
EndPos: 36,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12293,7 +12422,7 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12340,6 +12469,8 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "5.6", false, nil)

BIN
internal/php5/php5.go generated
View File

Binary file not shown.

97
internal/php5/php5.y
View File

@ -428,49 +428,56 @@ top_statement:
}
| T_USE use_declarations ';'
{
$$ = &ast.StmtUseList{ast.Node{}, nil, $2}
useList := &ast.StmtUseList{ast.Node{}, $2}
$$ = &ast.StmtUse{ast.Node{}, useList}
// save position
useList.GetNode().Position = position.NewNodeListPosition($2)
$$.GetNode().Position = position.NewTokensPosition($1, $3)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $3.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $3.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $3.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| T_USE T_FUNCTION use_function_declarations ';'
{
useType := &ast.Identifier{ast.Node{}, $2.Value}
$$ = &ast.StmtUseList{ast.Node{}, useType, $3}
identifier := &ast.Identifier{ast.Node{}, $2.Value}
useList := &ast.StmtUseList{ast.Node{}, $3}
useType := &ast.StmtUseType{ast.Node{}, identifier, useList}
$$ = &ast.StmtUse{ast.Node{}, useType}
// save position
useType.GetNode().Position = position.NewTokenPosition($2)
identifier.GetNode().Position = position.NewTokenPosition($2)
useList.GetNode().Position = position.NewNodeListPosition($3)
useType.GetNode().Position = position.NewTokenNodePosition($2, useList)
$$.GetNode().Position = position.NewTokensPosition($1, $4)
// save comments
yylex.(*Parser).setFreeFloating(identifier, token.Start, $2.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(useType, token.Start, $2.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $4.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $4.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $4.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| T_USE T_CONST use_const_declarations ';'
{
useType := &ast.Identifier{ast.Node{}, $2.Value}
$$ = &ast.StmtUseList{ast.Node{}, useType, $3}
identifier := &ast.Identifier{ast.Node{}, $2.Value}
useList := &ast.StmtUseList{ast.Node{}, $3}
useType := &ast.StmtUseType{ast.Node{}, identifier, useList}
$$ = &ast.StmtUse{ast.Node{}, useType}
// save position
useType.GetNode().Position = position.NewTokenPosition($2)
identifier.GetNode().Position = position.NewTokenPosition($2)
useList.GetNode().Position = position.NewNodeListPosition($3)
useType.GetNode().Position = position.NewTokenNodePosition($2, useList)
$$.GetNode().Position = position.NewTokensPosition($1, $4)
// save comments
yylex.(*Parser).setFreeFloating(identifier, token.Start, $2.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(useType, token.Start, $2.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $4.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $4.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $4.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -511,22 +518,19 @@ use_declaration:
namespace_name
{
name := &ast.NameName{ast.Node{}, $1}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
$$.GetNode().Position = position.NewNodeListPosition($1)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], $$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| namespace_name T_AS T_STRING
{
name := &ast.NameName{ast.Node{}, $1}
alias := &ast.Identifier{ast.Node{}, $3.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
@ -534,7 +538,6 @@ use_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($1, $3)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], $$)
yylex.(*Parser).setFreeFloating(name, token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $3.Tokens)
@ -543,16 +546,14 @@ use_declaration:
| T_NS_SEPARATOR namespace_name
{
name := &ast.NameName{ast.Node{}, $2}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
$$.GetNode().Position = position.NewNodeListPosition($2)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -560,7 +561,7 @@ use_declaration:
{
name := &ast.NameName{ast.Node{}, $2}
alias := &ast.Identifier{ast.Node{}, $4.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
@ -568,9 +569,7 @@ use_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($2, $4)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(name, token.End, $3.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $4.Tokens)
@ -600,22 +599,19 @@ use_function_declaration:
namespace_name
{
name := &ast.NameName{ast.Node{}, $1}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
$$.GetNode().Position = position.NewNodeListPosition($1)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], $$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| namespace_name T_AS T_STRING
{
name := &ast.NameName{ast.Node{}, $1}
alias := &ast.Identifier{ast.Node{}, $3.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
@ -623,7 +619,6 @@ use_function_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($1, $3)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], $$)
yylex.(*Parser).setFreeFloating(name, token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $3.Tokens)
@ -632,16 +627,14 @@ use_function_declaration:
| T_NS_SEPARATOR namespace_name
{
name := &ast.NameName{ast.Node{}, $2}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
$$.GetNode().Position = position.NewNodeListPosition($2)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -649,7 +642,7 @@ use_function_declaration:
{
name := &ast.NameName{ast.Node{}, $2}
alias := &ast.Identifier{ast.Node{}, $4.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
@ -657,9 +650,7 @@ use_function_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($2, $4)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(name, token.End, $3.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $4.Tokens)
@ -689,22 +680,19 @@ use_const_declaration:
namespace_name
{
name := &ast.NameName{ast.Node{}, $1}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
$$.GetNode().Position = position.NewNodeListPosition($1)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], $$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| namespace_name T_AS T_STRING
{
name := &ast.NameName{ast.Node{}, $1}
alias := &ast.Identifier{ast.Node{}, $3.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
@ -712,7 +700,6 @@ use_const_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($1, $3)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], $$)
yylex.(*Parser).setFreeFloating(name, token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $3.Tokens)
@ -721,16 +708,14 @@ use_const_declaration:
| T_NS_SEPARATOR namespace_name
{
name := &ast.NameName{ast.Node{}, $2}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
$$.GetNode().Position = position.NewNodeListPosition($2)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -738,7 +723,7 @@ use_const_declaration:
{
name := &ast.NameName{ast.Node{}, $2}
alias := &ast.Identifier{ast.Node{}, $4.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
@ -746,9 +731,7 @@ use_const_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($2, $4)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating(name, token.End, $3.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $4.Tokens)

204
internal/php5/php5_test.go
View File

@ -8525,7 +8525,7 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 154,
@ -8534,8 +8534,17 @@ func TestPhp5(t *testing.T) {
EndPos: 3289,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 154,
EndLine: 154,
StartPos: 3285,
EndPos: 3288,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 154,
@ -8570,7 +8579,8 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 155,
@ -8579,8 +8589,17 @@ func TestPhp5(t *testing.T) {
EndPos: 3299,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 155,
EndLine: 155,
StartPos: 3295,
EndPos: 3298,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 155,
@ -8615,7 +8634,8 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 156,
@ -8624,8 +8644,17 @@ func TestPhp5(t *testing.T) {
EndPos: 3316,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 156,
EndLine: 156,
StartPos: 3305,
EndPos: 3315,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 156,
@ -8671,7 +8700,8 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 157,
@ -8680,8 +8710,17 @@ func TestPhp5(t *testing.T) {
EndPos: 3330,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 157,
EndLine: 157,
StartPos: 3321,
EndPos: 3329,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 157,
@ -8714,7 +8753,7 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 157,
@ -8749,7 +8788,8 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 158,
@ -8758,8 +8798,17 @@ func TestPhp5(t *testing.T) {
EndPos: 3351,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 158,
EndLine: 158,
StartPos: 3335,
EndPos: 3350,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 158,
@ -8792,7 +8841,7 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 158,
@ -8838,7 +8887,8 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 159,
@ -8847,7 +8897,16 @@ func TestPhp5(t *testing.T) {
EndPos: 3375,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 159,
EndLine: 159,
StartPos: 3356,
EndPos: 3374,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 159,
@ -8858,8 +8917,17 @@ func TestPhp5(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 159,
EndLine: 159,
StartPos: 3365,
EndPos: 3374,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 159,
@ -8892,7 +8960,7 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 159,
@ -8927,7 +8995,9 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 160,
@ -8936,7 +9006,16 @@ func TestPhp5(t *testing.T) {
EndPos: 3413,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 160,
EndLine: 160,
StartPos: 3380,
EndPos: 3412,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 160,
@ -8947,8 +9026,17 @@ func TestPhp5(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 160,
EndLine: 160,
StartPos: 3389,
EndPos: 3412,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 160,
@ -8992,7 +9080,7 @@ func TestPhp5(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 160,
@ -9038,7 +9126,9 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
@ -9047,7 +9137,16 @@ func TestPhp5(t *testing.T) {
EndPos: 3434,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
EndLine: 161,
StartPos: 3418,
EndPos: 3433,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
@ -9058,8 +9157,17 @@ func TestPhp5(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
EndLine: 161,
StartPos: 3424,
EndPos: 3433,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
@ -9092,7 +9200,7 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
@ -9127,7 +9235,9 @@ func TestPhp5(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
@ -9136,7 +9246,16 @@ func TestPhp5(t *testing.T) {
EndPos: 3469,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
EndLine: 162,
StartPos: 3439,
EndPos: 3468,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
@ -9147,8 +9266,17 @@ func TestPhp5(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
EndLine: 162,
StartPos: 3445,
EndPos: 3468,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
@ -9192,7 +9320,7 @@ func TestPhp5(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
@ -9238,6 +9366,8 @@ func TestPhp5(t *testing.T) {
},
},
},
},
},
&ast.StmtExpression{
Node: ast.Node{
Position: &position.Position{

397
internal/php7/parser_test.go
View File

@ -12422,7 +12422,7 @@ func TestStmtUse(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12431,8 +12431,17 @@ func TestStmtUse(t *testing.T) {
EndPos: 11,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 10,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12468,6 +12477,7 @@ func TestStmtUse(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -12490,7 +12500,7 @@ func TestStmtUse_FullyQualified(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12499,8 +12509,17 @@ func TestStmtUse_FullyQualified(t *testing.T) {
EndPos: 12,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 8,
EndPos: 11,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12536,6 +12555,7 @@ func TestStmtUse_FullyQualified(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -12558,7 +12578,7 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12567,8 +12587,17 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
EndPos: 19,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 8,
EndPos: 18,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12615,6 +12644,7 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -12637,7 +12667,7 @@ func TestStmtUse_List(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12646,8 +12676,17 @@ func TestStmtUse_List(t *testing.T) {
EndPos: 16,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 15,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12680,7 +12719,7 @@ func TestStmtUse_List(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12716,6 +12755,7 @@ func TestStmtUse_List(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -12738,7 +12778,7 @@ func TestStmtUse_ListAlias(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12747,8 +12787,17 @@ func TestStmtUse_ListAlias(t *testing.T) {
EndPos: 23,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 22,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12781,7 +12830,7 @@ func TestStmtUse_ListAlias(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12828,6 +12877,7 @@ func TestStmtUse_ListAlias(t *testing.T) {
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -12850,7 +12900,7 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12859,7 +12909,16 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
EndPos: 26,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 25,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12870,8 +12929,17 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 16,
EndPos: 25,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12904,7 +12972,7 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12940,6 +13008,8 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -12962,7 +13032,7 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12971,7 +13041,16 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
EndPos: 40,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 39,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -12982,8 +13061,17 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 16,
EndPos: 39,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13027,7 +13115,7 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13074,6 +13162,8 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13096,7 +13186,7 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13105,7 +13195,17 @@ func TestStmtUse_ListConstType(t *testing.T) {
EndPos: 23,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 22,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13116,8 +13216,17 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 13,
EndPos: 22,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13150,7 +13259,7 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13186,6 +13295,8 @@ func TestStmtUse_ListConstType(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13208,7 +13319,7 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13217,7 +13328,16 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
EndPos: 37,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 36,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13228,8 +13348,17 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 13,
EndPos: 36,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13273,7 +13402,7 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13320,6 +13449,8 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13342,7 +13473,7 @@ func TestStmtUse_GroupUse(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtGroupUse{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13351,6 +13482,15 @@ func TestStmtUse_GroupUse(t *testing.T) {
EndPos: 22,
},
},
UseList: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 21,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13374,8 +13514,17 @@ func TestStmtUse_GroupUse(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 12,
EndPos: 20,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13408,7 +13557,7 @@ func TestStmtUse_GroupUse(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13444,6 +13593,8 @@ func TestStmtUse_GroupUse(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13466,7 +13617,7 @@ func TestStmtUse_GroupUseAlias(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtGroupUse{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13475,6 +13626,15 @@ func TestStmtUse_GroupUseAlias(t *testing.T) {
EndPos: 30,
},
},
UseList: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 29,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13498,8 +13658,17 @@ func TestStmtUse_GroupUseAlias(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 12,
EndPos: 28,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13532,7 +13701,7 @@ func TestStmtUse_GroupUseAlias(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13579,6 +13748,8 @@ func TestStmtUse_GroupUseAlias(t *testing.T) {
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13601,7 +13772,7 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtGroupUse{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13610,7 +13781,16 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
EndPos: 31,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 30,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13621,6 +13801,15 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
},
Value: []byte("function"),
},
Use: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 16,
EndPos: 30,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13644,8 +13833,17 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 21,
EndPos: 29,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13678,7 +13876,7 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13714,6 +13912,9 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
},
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13736,7 +13937,7 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtGroupUse{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13745,7 +13946,16 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
EndPos: 28,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 27,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13756,6 +13966,15 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
},
Value: []byte("const"),
},
Use: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 13,
EndPos: 27,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13779,8 +13998,17 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 18,
EndPos: 26,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13813,7 +14041,7 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13849,6 +14077,9 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
},
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)
@ -13871,7 +14102,7 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
},
},
Stmts: []ast.Vertex{
&ast.StmtGroupUse{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13880,6 +14111,15 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
EndPos: 37,
},
},
UseList: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 7,
EndPos: 36,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13903,17 +14143,26 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 18,
StartPos: 12,
EndPos: 35,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 12,
EndPos: 21,
},
},
UseType: &ast.Identifier{
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13924,6 +14173,15 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
},
Value: []byte("const"),
},
Use: &ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 18,
EndPos: 21,
},
},
Use: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13948,16 +14206,17 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
},
},
},
&ast.StmtUse{
},
&ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 32,
StartPos: 23,
EndPos: 35,
},
},
UseType: &ast.Identifier{
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
@ -13968,6 +14227,15 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
},
Value: []byte("function"),
},
Use: &ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 32,
EndPos: 35,
},
},
Use: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -13995,6 +14263,9 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
},
},
},
},
},
},
}
lexer := scanner.NewLexer([]byte(src), "7.4", false, nil)

BIN
internal/php7/php7.go generated
View File

Binary file not shown.

103
internal/php7/php7.y
View File

@ -528,58 +528,61 @@ top_statement:
}
| T_USE mixed_group_use_declaration ';'
{
$$ = $2
$$ = &ast.StmtUse{ast.Node{}, $2}
// save position
$$.GetNode().Position = position.NewTokensPosition($1, $3)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $3.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $3.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $3.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| T_USE use_type group_use_declaration ';'
{
$3.(*ast.StmtGroupUse).UseType = $2
$$ = $3
useType := &ast.StmtUseType{ast.Node{}, $2, $3}
$$ = &ast.StmtUse{ast.Node{}, useType}
// save position
useType.GetNode().Position = position.NewNodesPosition($2, $3)
$$.GetNode().Position = position.NewTokensPosition($1, $4)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $4.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $4.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $4.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| T_USE use_declarations ';'
{
$$ = &ast.StmtUseList{ast.Node{}, nil, $2}
useList := &ast.StmtUseList{ast.Node{}, $2}
$$ = &ast.StmtUse{ast.Node{}, useList}
// save position
useList.GetNode().Position = position.NewNodeListPosition($2)
$$.GetNode().Position = position.NewTokensPosition($1, $3)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $3.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $3.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $3.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| T_USE use_type use_declarations ';'
{
$$ = &ast.StmtUseList{ast.Node{}, $2, $3}
useList := &ast.StmtUseList{ast.Node{}, $3}
useType := &ast.StmtUseType{ast.Node{}, $2, useList}
$$ = &ast.StmtUse{ast.Node{}, useType}
// save position
useList.GetNode().Position = position.NewNodeListPosition($3)
useType.GetNode().Position = position.NewNodesPosition($2, useList)
$$.GetNode().Position = position.NewTokensPosition($1, $4)
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setFreeFloating($$, token.UseDeclarationList, $4.Tokens)
yylex.(*Parser).setToken($$, token.SemiColon, $4.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.End, $4.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -630,20 +633,20 @@ group_use_declaration:
namespace_name T_NS_SEPARATOR '{' unprefixed_use_declarations possible_comma '}'
{
name := &ast.NameName{ast.Node{}, $1}
$$ = &ast.StmtGroupUse{ast.Node{}, nil, name, $4}
useList := &ast.StmtUseList{ast.Node{}, $4}
$$ = &ast.StmtGroupUseList{ast.Node{}, name, useList}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
useList.GetNode().Position = position.NewNodeListPosition($4)
$$.GetNode().Position = position.NewNodeListTokenPosition($1, $6)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], name)
yylex.(*Parser).setFreeFloating(name, token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Slash, $3.Tokens)
yylex.(*Parser).setFreeFloatingTokens(useList, token.Start, append($2.Tokens, $3.Tokens...))
if $5 != nil {
yylex.(*Parser).setFreeFloating($$, token.Stmts, append($5.Tokens, $6.Tokens...))
yylex.(*Parser).setFreeFloatingTokens(useList, token.End, append($5.Tokens, $6.Tokens...))
} else {
yylex.(*Parser).setFreeFloating($$, token.Stmts, $6.Tokens)
yylex.(*Parser).setFreeFloating(useList, token.End, $6.Tokens)
}
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@ -651,22 +654,22 @@ group_use_declaration:
| T_NS_SEPARATOR namespace_name T_NS_SEPARATOR '{' unprefixed_use_declarations possible_comma '}'
{
name := &ast.NameName{ast.Node{}, $2}
$$ = &ast.StmtGroupUse{ast.Node{}, nil, name, $5}
useList := &ast.StmtUseList{ast.Node{}, $5}
$$ = &ast.StmtGroupUseList{ast.Node{}, name, useList}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
useList.GetNode().Position = position.NewNodeListPosition($5)
$$.GetNode().Position = position.NewTokensPosition($1, $7)
// save comments
yylex.(*Parser).setFreeFloating($$, token.UseType, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloating(name, token.End, $3.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Slash, $4.Tokens)
yylex.(*Parser).setFreeFloatingTokens(useList, token.Start, append($3.Tokens, $4.Tokens...))
if $6 != nil {
yylex.(*Parser).setFreeFloating($$, token.Stmts, append($6.Tokens, $7.Tokens...))
yylex.(*Parser).setFreeFloatingTokens(useList, token.End, append($6.Tokens, $7.Tokens...))
} else {
yylex.(*Parser).setFreeFloating($$, token.Stmts, $7.Tokens)
yylex.(*Parser).setFreeFloating(useList, token.End, $7.Tokens)
}
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -676,20 +679,20 @@ mixed_group_use_declaration:
namespace_name T_NS_SEPARATOR '{' inline_use_declarations possible_comma '}'
{
name := &ast.NameName{ast.Node{}, $1}
$$ = &ast.StmtGroupUse{ast.Node{}, nil, name, $4}
useList := &ast.StmtUseList{ast.Node{}, $4}
$$ = &ast.StmtGroupUseList{ast.Node{}, name, useList}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
useList.GetNode().Position = position.NewNodeListPosition($4)
$$.GetNode().Position = position.NewNodeListTokenPosition($1, $6)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], name)
yylex.(*Parser).setFreeFloating(name, token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Slash, $3.Tokens)
yylex.(*Parser).setFreeFloatingTokens(useList, token.Start, append($2.Tokens, $3.Tokens...))
if $5 != nil {
yylex.(*Parser).setFreeFloating($$, token.Stmts, append($5.Tokens, $6.Tokens...))
yylex.(*Parser).setFreeFloatingTokens(useList, token.End, append($5.Tokens, $6.Tokens...))
} else {
yylex.(*Parser).setFreeFloating($$, token.Stmts, $6.Tokens)
yylex.(*Parser).setFreeFloatingTokens(useList, token.End, $6.Tokens)
}
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
@ -697,22 +700,22 @@ mixed_group_use_declaration:
| T_NS_SEPARATOR namespace_name T_NS_SEPARATOR '{' inline_use_declarations possible_comma '}'
{
name := &ast.NameName{ast.Node{}, $2}
$$ = &ast.StmtGroupUse{ast.Node{}, nil, name, $5}
useList := &ast.StmtUseList{ast.Node{}, $5}
$$ = &ast.StmtGroupUseList{ast.Node{}, name, useList}
// save position
name.GetNode().Position = position.NewNodeListPosition($2)
useList.GetNode().Position = position.NewNodeListPosition($5)
$$.GetNode().Position = position.NewTokensPosition($1, $7)
// save comments
yylex.(*Parser).setFreeFloatingTokens($$, token.Use, $1.Tokens)
yylex.(*Parser).MoveFreeFloating($2[0], name)
yylex.(*Parser).setFreeFloating(name, token.End, $3.Tokens)
yylex.(*Parser).setFreeFloating($$, token.Slash, $4.Tokens)
yylex.(*Parser).setFreeFloatingTokens(useList, token.Start, append($3.Tokens, $4.Tokens...))
if $6 != nil {
yylex.(*Parser).setFreeFloating($$, token.Stmts, append($6.Tokens, $7.Tokens...))
yylex.(*Parser).setFreeFloatingTokens(useList, token.End, append($6.Tokens, $7.Tokens...))
} else {
yylex.(*Parser).setFreeFloating($$, token.Stmts, $7.Tokens)
yylex.(*Parser).setFreeFloating(useList, token.End, $7.Tokens)
}
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -792,8 +795,10 @@ inline_use_declaration:
}
| use_type unprefixed_use_declaration
{
$2.(*ast.StmtUse).UseType = $1
$$ = $2
$$ = &ast.StmtUseType{ast.Node{}, $1, $2}
// save position
$$.GetNode().Position = position.NewNodesPosition($1, $2)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -803,14 +808,11 @@ unprefixed_use_declaration:
namespace_name
{
name := &ast.NameName{ast.Node{}, $1}
$$ = &ast.StmtUse{ast.Node{}, nil, name, nil}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, nil}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
$$.GetNode().Position = position.NewNodeListPosition($1)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], name)
$$.GetNode().Position = position.NewNodePosition(name)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
@ -818,7 +820,7 @@ unprefixed_use_declaration:
{
name := &ast.NameName{ast.Node{}, $1}
alias := &ast.Identifier{ast.Node{}, $3.Value}
$$ = &ast.StmtUse{ast.Node{}, nil, name, alias}
$$ = &ast.StmtUseDeclaration{ast.Node{}, name, alias}
// save position
name.GetNode().Position = position.NewNodeListPosition($1)
@ -826,7 +828,6 @@ unprefixed_use_declaration:
$$.GetNode().Position = position.NewNodeListTokenPosition($1, $3)
// save comments
yylex.(*Parser).MoveFreeFloating($1[0], name)
yylex.(*Parser).setFreeFloating(name, token.End, $2.Tokens)
yylex.(*Parser).setFreeFloating(alias, token.Start, $3.Tokens)
@ -839,9 +840,6 @@ use_declaration:
{
$$ = $1
// save coments
yylex.(*Parser).MoveFreeFloating($1.(*ast.StmtUse).Use, $$)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}
| T_NS_SEPARATOR unprefixed_use_declaration
@ -849,8 +847,7 @@ use_declaration:
$$ = $2;
// save comments
yylex.(*Parser).setFreeFloating($$, token.Start, $1.Tokens)
yylex.(*Parser).setToken($$, token.Slash, $1.Tokens)
yylex.(*Parser).setFreeFloatingTokens($$, token.Start, $1.Tokens)
yylex.(*Parser).returnTokenToPool(yyDollar, &yyVAL)
}

396
internal/php7/php7_test.go
View File

@ -9013,7 +9013,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
@ -9022,8 +9022,17 @@ func TestPhp7(t *testing.T) {
EndPos: 3370,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
EndLine: 161,
StartPos: 3366,
EndPos: 3369,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 161,
@ -9058,7 +9067,8 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
@ -9067,8 +9077,17 @@ func TestPhp7(t *testing.T) {
EndPos: 3380,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
EndLine: 162,
StartPos: 3376,
EndPos: 3379,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 162,
@ -9103,7 +9122,8 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 163,
@ -9112,8 +9132,17 @@ func TestPhp7(t *testing.T) {
EndPos: 3397,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 163,
EndLine: 163,
StartPos: 3386,
EndPos: 3396,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 163,
@ -9159,7 +9188,8 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 164,
@ -9168,8 +9198,17 @@ func TestPhp7(t *testing.T) {
EndPos: 3411,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 164,
EndLine: 164,
StartPos: 3402,
EndPos: 3410,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 164,
@ -9202,7 +9241,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 164,
@ -9237,7 +9276,8 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 165,
@ -9246,8 +9286,17 @@ func TestPhp7(t *testing.T) {
EndPos: 3432,
},
},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 165,
EndLine: 165,
StartPos: 3416,
EndPos: 3431,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 165,
@ -9280,7 +9329,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 165,
@ -9326,7 +9375,8 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 166,
@ -9335,7 +9385,16 @@ func TestPhp7(t *testing.T) {
EndPos: 3456,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 166,
EndLine: 166,
StartPos: 3437,
EndPos: 3455,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 166,
@ -9346,8 +9405,17 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 166,
EndLine: 166,
StartPos: 3446,
EndPos: 3455,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 166,
@ -9380,7 +9448,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 166,
@ -9415,7 +9483,9 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 167,
@ -9424,7 +9494,16 @@ func TestPhp7(t *testing.T) {
EndPos: 3494,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 167,
EndLine: 167,
StartPos: 3461,
EndPos: 3493,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 167,
@ -9435,8 +9514,17 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("function"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 167,
EndLine: 167,
StartPos: 3470,
EndPos: 3493,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 167,
@ -9480,7 +9568,7 @@ func TestPhp7(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 167,
@ -9526,7 +9614,9 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 168,
@ -9535,7 +9625,16 @@ func TestPhp7(t *testing.T) {
EndPos: 3515,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 168,
EndLine: 168,
StartPos: 3499,
EndPos: 3514,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 168,
@ -9546,8 +9645,17 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 168,
EndLine: 168,
StartPos: 3505,
EndPos: 3514,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 168,
@ -9580,7 +9688,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 168,
@ -9615,7 +9723,9 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUseList{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 169,
@ -9624,7 +9734,16 @@ func TestPhp7(t *testing.T) {
EndPos: 3550,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 169,
EndLine: 169,
StartPos: 3520,
EndPos: 3549,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 169,
@ -9635,8 +9754,17 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("const"),
},
Uses: []ast.Vertex{
&ast.StmtUse{
Use: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 169,
EndLine: 169,
StartPos: 3526,
EndPos: 3549,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 169,
@ -9680,7 +9808,7 @@ func TestPhp7(t *testing.T) {
Value: []byte("foo"),
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 169,
@ -9726,7 +9854,9 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtGroupUse{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 171,
@ -9735,6 +9865,15 @@ func TestPhp7(t *testing.T) {
EndPos: 3572,
},
},
UseList: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 171,
EndLine: 171,
StartPos: 3556,
EndPos: 3571,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -9758,8 +9897,17 @@ func TestPhp7(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 171,
EndLine: 171,
StartPos: 3562,
EndPos: 3570,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 171,
@ -9792,7 +9940,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 171,
@ -9827,7 +9975,9 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtGroupUse{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 172,
@ -9836,6 +9986,15 @@ func TestPhp7(t *testing.T) {
EndPos: 3600,
},
},
UseList: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 172,
EndLine: 172,
StartPos: 3577,
EndPos: 3599,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -9859,8 +10018,17 @@ func TestPhp7(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 172,
EndLine: 172,
StartPos: 3582,
EndPos: 3598,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 172,
@ -9893,7 +10061,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 172,
@ -9939,7 +10107,9 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtGroupUse{
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
@ -9948,7 +10118,16 @@ func TestPhp7(t *testing.T) {
EndPos: 3629,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
EndLine: 173,
StartPos: 3605,
EndPos: 3628,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
@ -9959,6 +10138,15 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("function"),
},
Use: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
EndLine: 173,
StartPos: 3614,
EndPos: 3628,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -9982,8 +10170,17 @@ func TestPhp7(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
EndLine: 173,
StartPos: 3619,
EndPos: 3627,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
@ -10016,7 +10213,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 173,
@ -10051,7 +10248,10 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtGroupUse{
},
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
@ -10060,7 +10260,16 @@ func TestPhp7(t *testing.T) {
EndPos: 3656,
},
},
UseType: &ast.Identifier{
UseList: &ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
EndLine: 174,
StartPos: 3634,
EndPos: 3655,
},
},
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
@ -10071,6 +10280,15 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("const"),
},
Use: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
EndLine: 174,
StartPos: 3640,
EndPos: 3655,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -10094,8 +10312,17 @@ func TestPhp7(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
EndLine: 174,
StartPos: 3646,
EndPos: 3654,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
@ -10128,7 +10355,7 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
&ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 174,
@ -10163,7 +10390,10 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtGroupUse{
},
},
},
&ast.StmtUse{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
@ -10172,6 +10402,15 @@ func TestPhp7(t *testing.T) {
EndPos: 3691,
},
},
UseList: &ast.StmtGroupUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
EndLine: 175,
StartPos: 3661,
EndPos: 3690,
},
},
Prefix: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -10195,17 +10434,26 @@ func TestPhp7(t *testing.T) {
},
},
},
UseList: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
EndLine: 175,
StartPos: 3672,
StartPos: 3666,
EndPos: 3689,
},
},
UseDeclarations: []ast.Vertex{
&ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
EndLine: 175,
StartPos: 3666,
EndPos: 3675,
},
},
UseType: &ast.Identifier{
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
@ -10216,6 +10464,15 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("const"),
},
Use: &ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
EndLine: 175,
StartPos: 3672,
EndPos: 3675,
},
},
Use: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -10240,16 +10497,17 @@ func TestPhp7(t *testing.T) {
},
},
},
&ast.StmtUse{
},
&ast.StmtUseType{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
EndLine: 175,
StartPos: 3686,
StartPos: 3677,
EndPos: 3689,
},
},
UseType: &ast.Identifier{
Type: &ast.Identifier{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
@ -10260,6 +10518,15 @@ func TestPhp7(t *testing.T) {
},
Value: []byte("function"),
},
Use: &ast.StmtUseDeclaration{
Node: ast.Node{
Position: &position.Position{
StartLine: 175,
EndLine: 175,
StartPos: 3686,
EndPos: 3689,
},
},
Use: &ast.NameName{
Node: ast.Node{
Position: &position.Position{
@ -10286,6 +10553,9 @@ func TestPhp7(t *testing.T) {
},
},
},
},
},
},
&ast.StmtExpression{
Node: ast.Node{
Position: &position.Position{

4
pkg/ast/ast.go
View File

@ -59,7 +59,6 @@ type NodeVisitor interface {
StmtFunction(n *StmtFunction)
StmtGlobal(n *StmtGlobal)
StmtGoto(n *StmtGoto)
StmtGroupUse(n *StmtGroupUse)
StmtHaltCompiler(n *StmtHaltCompiler)
StmtIf(n *StmtIf)
StmtInlineHtml(n *StmtInlineHtml)
@ -85,7 +84,10 @@ type NodeVisitor interface {
StmtTry(n *StmtTry)
StmtUnset(n *StmtUnset)
StmtUse(n *StmtUse)
StmtGroupUseList(n *StmtGroupUseList)
StmtUseList(n *StmtUseList)
StmtUseDeclaration(n *StmtUseDeclaration)
StmtUseType(n *StmtUseType)
StmtWhile(n *StmtWhile)
ExprArray(n *ExprArray)

52
pkg/ast/node.go
View File

@ -532,18 +532,6 @@ func (n *StmtGoto) Accept(v NodeVisitor) {
v.StmtGoto(n)
}
// StmtGroupUse node
type StmtGroupUse struct {
Node
UseType Vertex
Prefix Vertex
UseList []Vertex
}
func (n *StmtGroupUse) Accept(v NodeVisitor) {
v.StmtGroupUse(n)
}
// StmtHaltCompiler node
type StmtHaltCompiler struct {
Node
@ -804,26 +792,56 @@ func (n *StmtUnset) Accept(v NodeVisitor) {
// StmtUse node
type StmtUse struct {
Node
UseType Vertex
Use Vertex
Alias Vertex
UseList Vertex
}
func (n *StmtUse) Accept(v NodeVisitor) {
v.StmtUse(n)
}
// StmtGroupUseList node
type StmtGroupUseList struct {
Node
Prefix Vertex
UseList Vertex
}
func (n *StmtGroupUseList) Accept(v NodeVisitor) {
v.StmtGroupUseList(n)
}
// StmtUseList node
type StmtUseList struct {
Node
UseType Vertex
Uses []Vertex
UseDeclarations []Vertex
}
func (n *StmtUseList) Accept(v NodeVisitor) {
v.StmtUseList(n)
}
// StmtUseDeclaration node
type StmtUseDeclaration struct {
Node
Use Vertex
Alias Vertex
}
func (n *StmtUseDeclaration) Accept(v NodeVisitor) {
v.StmtUseDeclaration(n)
}
// StmtUseType node
type StmtUseType struct {
Node
Type Vertex
Use Vertex
}
func (n *StmtUseType) Accept(v NodeVisitor) {
v.StmtUseType(n)
}
// StmtWhile node
type StmtWhile struct {
Node

90
pkg/ast/traverser/dfs.go
View File

@ -745,30 +745,6 @@ func (t *DFS) Traverse(n ast.Vertex) {
t.Traverse(nn.Label)
t.visitor.Leave("Label", true)
}
case *ast.StmtGroupUse:
if nn == nil {
return
}
if !t.visitor.EnterNode(nn) {
return
}
if nn.UseType != nil {
t.visitor.Enter("UseType", true)
t.Traverse(nn.UseType)
t.visitor.Leave("UseType", true)
}
if nn.Prefix != nil {
t.visitor.Enter("Prefix", true)
t.Traverse(nn.Prefix)
t.visitor.Leave("Prefix", true)
}
if nn.UseList != nil {
t.visitor.Enter("UseList", false)
for _, c := range nn.UseList {
t.Traverse(c)
}
t.visitor.Leave("UseList", false)
}
case *ast.StmtHaltCompiler:
if nn == nil {
return
@ -1174,10 +1150,48 @@ func (t *DFS) Traverse(n ast.Vertex) {
if !t.visitor.EnterNode(nn) {
return
}
if nn.UseType != nil {
t.visitor.Enter("UseType", true)
t.Traverse(nn.UseType)
t.visitor.Leave("UseType", true)
if nn.UseList != nil {
t.visitor.Enter("UseList", true)
t.Traverse(nn.UseList)
t.visitor.Leave("UseList", true)
}
case *ast.StmtGroupUseList:
if nn == nil {
return
}
if !t.visitor.EnterNode(nn) {
return
}
if nn.Prefix != nil {
t.visitor.Enter("Prefix", true)
t.Traverse(nn.Prefix)
t.visitor.Leave("Prefix", true)
}
if nn.UseList != nil {
t.visitor.Enter("UseList", true)
t.Traverse(nn.UseList)
t.visitor.Leave("UseList", true)
}
case *ast.StmtUseList:
if nn == nil {
return
}
if !t.visitor.EnterNode(nn) {
return
}
if nn.UseDeclarations != nil {
t.visitor.Enter("UseDeclarations", false)
for _, c := range nn.UseDeclarations {
t.Traverse(c)
}
t.visitor.Leave("UseDeclarations", false)
}
case *ast.StmtUseDeclaration:
if nn == nil {
return
}
if !t.visitor.EnterNode(nn) {
return
}
if nn.Use != nil {
t.visitor.Enter("Use", true)
@ -1189,24 +1203,22 @@ func (t *DFS) Traverse(n ast.Vertex) {
t.Traverse(nn.Alias)
t.visitor.Leave("Alias", true)
}
case *ast.StmtUseList:
case *ast.StmtUseType:
if nn == nil {
return
}
if !t.visitor.EnterNode(nn) {
return
}
if nn.UseType != nil {
t.visitor.Enter("UseType", true)
t.Traverse(nn.UseType)
t.visitor.Leave("UseType", true)
if nn.Type != nil {
t.visitor.Enter("Type", true)
t.Traverse(nn.Type)
t.visitor.Leave("Type", true)
}
if nn.Uses != nil {
t.visitor.Enter("Uses", false)
for _, c := range nn.Uses {
t.Traverse(c)
}
t.visitor.Leave("Uses", false)
if nn.Use != nil {
t.visitor.Enter("Use", true)
t.Traverse(nn.Use)
t.visitor.Leave("Use", true)
}
case *ast.StmtWhile:
if nn == nil {

24
pkg/ast/visitor/dump.go
View File

@ -437,12 +437,6 @@ func (v *Dump) StmtGoto(n *ast.StmtGoto) {
v.printNode(n.GetNode())
}
func (v *Dump) StmtGroupUse(n *ast.StmtGroupUse) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtGroupUse{\n")
v.printNode(n.GetNode())
}
func (v *Dump) StmtHaltCompiler(n *ast.StmtHaltCompiler) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtHaltCompiler{\n")
@ -596,12 +590,30 @@ func (v *Dump) StmtUse(n *ast.StmtUse) {
v.printNode(n.GetNode())
}
func (v *Dump) StmtGroupUseList(n *ast.StmtGroupUseList) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtGroupUseList{\n")
v.printNode(n.GetNode())
}
func (v *Dump) StmtUseList(n *ast.StmtUseList) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtUseList{\n")
v.printNode(n.GetNode())
}
func (v *Dump) StmtUseDeclaration(n *ast.StmtUseDeclaration) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtUseDeclaration{\n")
v.printNode(n.GetNode())
}
func (v *Dump) StmtUseType(n *ast.StmtUseType) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtUseType{\n")
v.printNode(n.GetNode())
}
func (v *Dump) StmtWhile(n *ast.StmtWhile) {
v.printIndentIfNotSingle(v.indent - 1)
v.print("&ast.StmtWhile{\n")

60
pkg/ast/visitor/namespace_resolver.go
View File

@ -14,6 +14,8 @@ type NamespaceResolver struct {
ResolvedNames map[ast.Vertex]string
goDeep bool
useType string
usePrefix []ast.Vertex
}
// NewNamespaceResolver NamespaceResolver type constructor
@ -45,28 +47,28 @@ func (nsr *NamespaceResolver) StmtNamespace(n *ast.StmtNamespace) {
}
}
func (nsr *NamespaceResolver) StmtUseList(n *ast.StmtUseList) {
useType := ""
if n.UseType != nil {
useType = string(n.UseType.(*ast.Identifier).Value)
func (nsr *NamespaceResolver) StmtUseType(n *ast.StmtUseType) {
if n.Type != nil {
nsr.useType = string(n.Type.(*ast.Identifier).Value)
}
for _, nn := range n.Uses {
nsr.AddAlias(useType, nn, nil)
}
nsr.goDeep = false
}
func (nsr *NamespaceResolver) StmtGroupUse(n *ast.StmtGroupUse) {
useType := ""
if n.UseType != nil {
useType = string(n.UseType.(*ast.Identifier).Value)
func (nsr *NamespaceResolver) StmtGroupUseList(n *ast.StmtGroupUseList) {
if n.Prefix != nil {
nsr.usePrefix = n.Prefix.(*ast.NameName).Parts
}
}
func (nsr *NamespaceResolver) StmtUseDeclaration(n *ast.StmtUseDeclaration) {
useNameParts := n.Use.(*ast.NameName).Parts
var alias string
if n.Alias == nil {
alias = string(useNameParts[len(useNameParts)-1].(*ast.NameNamePart).Value)
} else {
alias = string(n.Alias.(*ast.Identifier).Value)
}
for _, nn := range n.UseList {
nsr.AddAlias(useType, nn, n.Prefix.(*ast.NameName).Parts)
}
nsr.Namespace.AddAlias(nsr.useType, concatNameParts(nsr.usePrefix, useNameParts), alias)
nsr.goDeep = false
}
@ -213,26 +215,10 @@ func (nsr *NamespaceResolver) LeaveNode(n ast.Vertex) {
if nn.Stmts != nil {
nsr.Namespace = NewNamespace("")
}
}
}
// AddAlias adds a new alias
func (nsr *NamespaceResolver) AddAlias(useType string, nn ast.Vertex, prefix []ast.Vertex) {
switch use := nn.(type) {
case *ast.StmtUse:
if use.UseType != nil {
useType = string(use.UseType.(*ast.Identifier).Value)
}
useNameParts := use.Use.(*ast.NameName).Parts
var alias string
if use.Alias == nil {
alias = string(useNameParts[len(useNameParts)-1].(*ast.NameNamePart).Value)
} else {
alias = string(use.Alias.(*ast.Identifier).Value)
}
nsr.Namespace.AddAlias(useType, concatNameParts(prefix, useNameParts), alias)
case *ast.StmtUseType:
nsr.useType = ""
case *ast.StmtGroupUseList:
nsr.usePrefix = nil
}
}

105
pkg/ast/visitor/namespace_resolver_test.go
View File

@ -16,13 +16,15 @@ func TestResolveStaticCall(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
&ast.ExprStaticCall{
Class: nameBC,
Call: &ast.Identifier{Value: []byte("foo")},
@ -48,13 +50,15 @@ func TestResolveStaticPropertyFetch(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
&ast.ExprStaticPropertyFetch{
Class: nameBC,
Property: &ast.Identifier{Value: []byte("foo")},
@ -79,13 +83,15 @@ func TestResolveClassConstFetch(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
&ast.ExprClassConstFetch{
Class: nameBC,
ConstantName: &ast.Identifier{Value: []byte("FOO")},
@ -110,13 +116,15 @@ func TestResolveNew(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
&ast.ExprNew{
Class: nameBC,
ArgumentList: &ast.ArgumentList{},
@ -141,13 +149,15 @@ func TestResolveInstanceOf(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
&ast.ExprInstanceOf{
Expr: &ast.ExprVariable{VarName: &ast.Identifier{Value: []byte("foo")}},
Class: nameBC,
@ -175,17 +185,18 @@ func TestResolveInstanceCatch(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
&ast.StmtUse{
}, &ast.StmtUseDeclaration{
Use: nameDE,
Alias: &ast.Identifier{Value: []byte("F")},
},
},
},
},
&ast.StmtTry{
Stmts: []ast.Vertex{},
Catches: []ast.Vertex{
@ -220,14 +231,18 @@ func TestResolveFunctionCall(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
UseType: &ast.Identifier{Value: []byte("function")},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("function")},
Use: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
},
&ast.ExprFunctionCall{
Function: nameB,
ArgumentList: &ast.ArgumentList{},
@ -252,14 +267,18 @@ func TestResolveConstFetch(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
UseType: &ast.Identifier{Value: []byte("const")},
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("const")},
Use: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
},
&ast.ExprConstFetch{
Const: nameB,
},
@ -286,28 +305,42 @@ func TestResolveGroupUse(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtGroupUse{
Prefix: nameAB,
UseList: []ast.Vertex{
&ast.StmtUse{
UseType: &ast.Identifier{Value: []byte("Function")},
UseList: &ast.StmtGroupUseList{
Prefix: nameAB,
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("Function")},
Use: &ast.StmtUseDeclaration{
Use: nameF,
},
&ast.StmtUse{
UseType: &ast.Identifier{Value: []byte("const")},
},
&ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("const")},
Use: &ast.StmtUseDeclaration{
Use: nameC,
},
},
},
&ast.StmtGroupUse{
Prefix: nameBD,
UseType: &ast.Identifier{Value: []byte("Function")},
UseList: []ast.Vertex{
},
},
},
&ast.StmtUse{
UseList: &ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("Function")},
Use: &ast.StmtGroupUseList{
Prefix: nameBD,
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameE,
},
},
},
},
},
},
&ast.ExprConstFetch{
Const: nameC,
},
@ -347,13 +380,15 @@ func TestResolveTraitUse(t *testing.T) {
stxTree := &ast.StmtStmtList{
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAB,
},
},
},
},
&ast.StmtTraitUse{
Traits: []ast.Vertex{
nameB,
@ -668,13 +703,15 @@ func TestResolveNamespaces(t *testing.T) {
&ast.StmtNamespace{
NamespaceName: namespaceCD,
Stmts: []ast.Vertex{
&ast.StmtUseList{
Uses: []ast.Vertex{
&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: nameAC,
},
},
},
},
&ast.ExprStaticCall{
Class: relativeNameCE,
Call: &ast.Identifier{Value: []byte("foo")},

16
pkg/ast/visitor/null.go
View File

@ -182,10 +182,6 @@ func (v *Null) StmtGoto(_ *ast.StmtGoto) {
// do nothing
}
func (v *Null) StmtGroupUse(_ *ast.StmtGroupUse) {
// do nothing
}
func (v *Null) StmtHaltCompiler(_ *ast.StmtHaltCompiler) {
// do nothing
}
@ -286,10 +282,22 @@ func (v *Null) StmtUse(_ *ast.StmtUse) {
// do nothing
}
func (v *Null) StmtGroupUseList(_ *ast.StmtGroupUseList) {
// do nothing
}
func (v *Null) StmtUseList(_ *ast.StmtUseList) {
// do nothing
}
func (v *Null) StmtUseDeclaration(_ *ast.StmtUseDeclaration) {
// do nothing
}
func (v *Null) StmtUseType(_ *ast.StmtUseType) {
// do nothing
}
func (v *Null) StmtWhile(_ *ast.StmtWhile) {
// do nothing
}

80
pkg/printer/pretty_printer.go
View File

@ -353,8 +353,6 @@ func (p *PrettyPrinter) printNode(n ast.Vertex) {
p.printStmtGlobal(n)
case *ast.StmtGoto:
p.printStmtGoto(n)
case *ast.StmtGroupUse:
p.printStmtGroupUse(n)
case *ast.StmtHaltCompiler:
p.printStmtHaltCompiler(n)
case *ast.StmtIf:
@ -399,10 +397,16 @@ func (p *PrettyPrinter) printNode(n ast.Vertex) {
p.printStmtTry(n)
case *ast.StmtUnset:
p.printStmtUnset(n)
case *ast.StmtUseList:
p.printStmtUseList(n)
case *ast.StmtUse:
p.printStmtUse(n)
case *ast.StmtGroupUseList:
p.printStmtGroupUseList(n)
case *ast.StmtUseList:
p.printStmtUseList(n)
case *ast.StmtUseDeclaration:
p.printStmtUseDeclaration(n)
case *ast.StmtUseType:
p.printStmtUseType(n)
case *ast.StmtWhile:
p.printStmtWhile(n)
}
@ -1847,22 +1851,6 @@ func (p *PrettyPrinter) printStmtGoto(n ast.Vertex) {
io.WriteString(p.w, ";")
}
func (p *PrettyPrinter) printStmtGroupUse(n ast.Vertex) {
nn := n.(*ast.StmtGroupUse)
io.WriteString(p.w, "use ")
if nn.UseType != nil {
p.Print(nn.UseType)
io.WriteString(p.w, " ")
}
p.Print(nn.Prefix)
io.WriteString(p.w, "\\{")
p.joinPrint(", ", nn.UseList)
io.WriteString(p.w, "};")
}
func (p *PrettyPrinter) printStmtHaltCompiler(n ast.Vertex) {
io.WriteString(p.w, "__halt_compiler();")
}
@ -2146,27 +2134,34 @@ func (p *PrettyPrinter) printStmtUnset(n ast.Vertex) {
io.WriteString(p.w, ");")
}
func (p *PrettyPrinter) printStmtUseList(n ast.Vertex) {
nn := n.(*ast.StmtUseList)
io.WriteString(p.w, "use ")
if nn.UseType != nil {
p.Print(nn.UseType)
io.WriteString(p.w, " ")
}
p.joinPrint(", ", nn.Uses)
io.WriteString(p.w, ";")
}
func (p *PrettyPrinter) printStmtUse(n ast.Vertex) {
nn := n.(*ast.StmtUse)
if nn.UseType != nil {
p.Print(nn.UseType)
io.WriteString(p.w, " ")
}
io.WriteString(p.w, "use ")
p.Print(nn.UseList)
io.WriteString(p.w, ";")
}
func (p *PrettyPrinter) printStmtGroupUseList(n ast.Vertex) {
nn := n.(*ast.StmtGroupUseList)
p.Print(nn.Prefix)
io.WriteString(p.w, "\\{")
p.Print(nn.UseList)
io.WriteString(p.w, "}")
}
func (p *PrettyPrinter) printStmtUseList(n ast.Vertex) {
nn := n.(*ast.StmtUseList)
p.joinPrint(", ", nn.UseDeclarations)
}
func (p *PrettyPrinter) printStmtUseDeclaration(n ast.Vertex) {
nn := n.(*ast.StmtUseDeclaration)
p.Print(nn.Use)
@ -2176,6 +2171,15 @@ func (p *PrettyPrinter) printStmtUse(n ast.Vertex) {
}
}
func (p *PrettyPrinter) printStmtUseType(n ast.Vertex) {
nn := n.(*ast.StmtUseType)
p.Print(nn.Type)
io.WriteString(p.w, " ")
p.Print(nn.Use)
}
func (p *PrettyPrinter) printStmtWhile(n ast.Vertex) {
nn := n.(*ast.StmtWhile)

109
pkg/printer/pretty_printer_test.go
View File

@ -3256,32 +3256,6 @@ func TestPrintStmtGoto(t *testing.T) {
}
}
func TestPrintStmtGroupUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
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")},
},
&ast.StmtUse{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
})
expected := `use function Foo\{Bar as Baz, Quuz};`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrintHaltCompiler(t *testing.T) {
o := bytes.NewBufferString("")
@ -3975,24 +3949,15 @@ func TestPrintStmtUset(t *testing.T) {
}
}
func TestPrintStmtUseList(t *testing.T) {
func TestPrintUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
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")},
},
&ast.StmtUse{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
},
p.Print(&ast.StmtUse{
UseList: &ast.StmtUseList{},
})
expected := `use function Foo as Bar, Baz;`
expected := `use ;`
actual := o.String()
if expected != actual {
@ -4000,14 +3965,74 @@ func TestPrintStmtUseList(t *testing.T) {
}
}
func TestPrintUse(t *testing.T) {
func TestPrintStmtGroupUseList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
p.Print(&ast.StmtUse{
UseType: &ast.Identifier{Value: []byte("function")},
p.Print(&ast.StmtGroupUseList{
Prefix: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
UseList: &ast.StmtUseList{},
})
expected := `Foo\{}`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrintStmtUseList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
p.Print(&ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
},
&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
},
})
expected := `Foo as Bar, Baz`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrintUseDeclaration(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
p.Print(&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
})
expected := `Foo as Bar`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrintUseType(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrettyPrinter(o, " ")
p.Print(&ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("function")},
Use: &ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
},
})
expected := `function Foo as Bar`

178
pkg/printer/printer.go
View File

@ -18,6 +18,8 @@ const (
type Printer struct {
w io.Writer
s printerState
bufStart string
bufEnd string
}
// NewPrinter - Constructor for Printer
@ -60,6 +62,21 @@ func (p *Printer) printNodes(nn []ast.Vertex) {
}
}
func (p *Printer) printFreeFloatingOrDefault(n ast.Vertex, pos token.Position, def string) {
if n == nil {
return
}
if len(n.GetNode().Tokens[pos]) == 0 {
io.WriteString(p.w, def)
return
}
for _, m := range n.GetNode().Tokens[pos] {
io.WriteString(p.w, string(m.Value))
}
}
func (p *Printer) printFreeFloating(n ast.Vertex, pos token.Position) {
if n == nil {
return
@ -374,8 +391,6 @@ func (p *Printer) printNode(n ast.Vertex) {
p.printStmtGlobal(n)
case *ast.StmtGoto:
p.printStmtGoto(n)
case *ast.StmtGroupUse:
p.printStmtGroupUse(n)
case *ast.StmtHaltCompiler:
p.printStmtHaltCompiler(n)
case *ast.StmtIf:
@ -422,10 +437,16 @@ func (p *Printer) printNode(n ast.Vertex) {
p.printStmtTry(n)
case *ast.StmtUnset:
p.printStmtUnset(n)
case *ast.StmtUseList:
p.printStmtUseList(n)
case *ast.StmtUse:
p.printStmtUse(n)
case *ast.StmtGroupUseList:
p.printStmtGroupUseList(n)
case *ast.StmtUseList:
p.printStmtUseList(n)
case *ast.StmtUseDeclaration:
p.printStmtUseDeclaration(n)
case *ast.StmtUseType:
p.printStmtUseType(n)
case *ast.StmtWhile:
p.printStmtWhile(n)
}
@ -443,8 +464,11 @@ func (p *Printer) printNodeRoot(n ast.Vertex) {
func (p *Printer) printNodeIdentifier(n ast.Vertex) {
nn := n.(*ast.Identifier)
p.printFreeFloating(nn, token.Start)
p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
p.bufStart = ""
io.WriteString(p.w, string(nn.Value))
p.printFreeFloating(nn, token.End)
}
@ -519,7 +543,8 @@ func (p *Printer) printNodeArgument(n ast.Vertex) {
func (p *Printer) printNameNamePart(n ast.Vertex) {
nn := n.(*ast.NameNamePart)
p.printFreeFloating(nn, token.Start)
p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
p.bufStart = ""
io.WriteString(p.w, string(nn.Value))
@ -532,22 +557,26 @@ func (p *Printer) printNameName(n ast.Vertex) {
p.joinPrint("\\", nn.Parts)
p.printFreeFloating(nn, token.End)
p.printFreeFloatingOrDefault(nn, token.End, p.bufEnd)
p.bufEnd = ""
}
func (p *Printer) printNameFullyQualified(n ast.Vertex) {
nn := n.(*ast.NameFullyQualified)
p.printFreeFloating(nn, token.Start)
p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
p.bufStart = ""
io.WriteString(p.w, "\\")
p.joinPrint("\\", nn.Parts)
p.printFreeFloating(nn, token.End)
p.printFreeFloatingOrDefault(nn, token.End, p.bufEnd)
p.bufEnd = ""
}
func (p *Printer) printNameRelative(n ast.Vertex) {
nn := n.(*ast.NameRelative)
p.printFreeFloating(nn, token.Start)
p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
p.bufStart = ""
io.WriteString(p.w, "namespace")
p.printFreeFloating(nn, token.Namespace)
@ -557,7 +586,8 @@ func (p *Printer) printNameRelative(n ast.Vertex) {
p.Print(part)
}
p.printFreeFloating(nn, token.End)
p.printFreeFloatingOrDefault(nn, token.End, p.bufEnd)
p.bufEnd = ""
}
// scalar
@ -2710,41 +2740,6 @@ func (p *Printer) printStmtGoto(n ast.Vertex) {
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)
@ -3197,59 +3192,78 @@ func (p *Printer) printStmtUnset(n ast.Vertex) {
p.printFreeFloating(nn, token.End)
}
func (p *Printer) printStmtUseList(n ast.Vertex) {
nn := n.(*ast.StmtUseList)
func (p *Printer) printStmtUse(n ast.Vertex) {
nn := n.(*ast.StmtUse)
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)
p.bufStart = " "
p.Print(nn.UseList)
p.printFreeFloatingOrDefault(nn, token.End, ";")
}
func (p *Printer) printStmtGroupUseList(n ast.Vertex) {
nn := n.(*ast.StmtGroupUseList)
p.printFreeFloating(nn, token.Start)
p.Print(nn.Prefix)
p.bufStart = "\\{"
p.bufEnd = "}"
p.Print(nn.UseList)
p.printFreeFloating(nn, token.End)
}
func (p *Printer) printStmtUseList(n ast.Vertex) {
nn := n.(*ast.StmtUseList)
bufEnd := p.bufEnd
p.bufEnd = ""
if p.bufStart == "\\{" {
p.printFreeFloatingOrDefault(nn, token.Start, p.bufStart)
p.bufStart = ""
} else {
p.printFreeFloating(nn, token.Start)
}
if nn.Uses[0].GetNode().Tokens.IsEmpty() {
io.WriteString(p.w, " ")
}
p.joinPrint(",", nn.Uses)
p.printFreeFloating(nn, token.UseDeclarationList)
p.joinPrint(",", nn.UseDeclarations)
p.printFreeFloating(nn, token.SemiColon)
if nn.GetNode().Tokens.IsEmpty() {
io.WriteString(p.w, ";")
p.printFreeFloatingOrDefault(nn, token.End, bufEnd)
}
func (p *Printer) printStmtUseDeclaration(n ast.Vertex) {
nn := n.(*ast.StmtUseDeclaration)
p.printFreeFloating(nn, token.Start)
if nn.Alias != nil {
p.bufEnd = " "
}
p.Print(nn.Use)
if nn.Alias != nil {
io.WriteString(p.w, "as")
p.bufStart = " "
p.Print(nn.Alias)
}
p.printFreeFloating(nn, token.End)
}
func (p *Printer) printStmtUse(n ast.Vertex) {
nn := n.(*ast.StmtUse)
func (p *Printer) printStmtUseType(n ast.Vertex) {
nn := n.(*ast.StmtUseType)
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.Type)
p.bufStart = " "
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)
}

107
pkg/printer/printer_test.go
View File

@ -3673,32 +3673,6 @@ func TestPrinterPrintStmtGoto(t *testing.T) {
}
}
func TestPrinterPrintStmtGroupUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
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")},
},
&ast.StmtUse{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Quuz")}}},
},
},
})
expected := `use function Foo\{Bar as Baz,Quuz};`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrinterPrintHaltCompiler(t *testing.T) {
o := bytes.NewBufferString("")
@ -4412,24 +4386,21 @@ func TestPrinterPrintStmtUnset(t *testing.T) {
}
}
func TestPrinterPrintStmtUseList(t *testing.T) {
func TestPrinterPrintUse(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
p.Print(&ast.StmtUseList{
UseType: &ast.Identifier{Value: []byte("function")},
Uses: []ast.Vertex{
&ast.StmtUse{
p.Print(&ast.StmtUse{
UseList: &ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
},
&ast.StmtUse{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
},
})
expected := `use function Foo as Bar,Baz;`
expected := `use Foo;`
actual := o.String()
if expected != actual {
@ -4437,14 +4408,74 @@ func TestPrinterPrintStmtUseList(t *testing.T) {
}
}
func TestPrinterPrintUse(t *testing.T) {
func TestPrinterPrintStmtGroupUseList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
p.Print(&ast.StmtUse{
UseType: &ast.Identifier{Value: []byte("function")},
p.Print(&ast.StmtGroupUseList{
Prefix: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
UseList: &ast.StmtUseList{},
})
expected := `Foo\{}`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrinterPrintStmtUseList(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
p.Print(&ast.StmtUseList{
UseDeclarations: []ast.Vertex{
&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
},
&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Baz")}}},
},
},
})
expected := `Foo as Bar,Baz`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrinterPrintUseDeclaration(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
p.Print(&ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
})
expected := `Foo as Bar`
actual := o.String()
if expected != actual {
t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
}
}
func TestPrinterPrintUseType(t *testing.T) {
o := bytes.NewBufferString("")
p := printer.NewPrinter(o)
p.Print(&ast.StmtUseType{
Type: &ast.Identifier{Value: []byte("function")},
Use: &ast.StmtUseDeclaration{
Use: &ast.NameName{Parts: []ast.Vertex{&ast.NameNamePart{Value: []byte("Foo")}}},
Alias: &ast.Identifier{Value: []byte("Bar")},
},
})
expected := `function Foo as Bar`

1
pkg/token/position.go
View File

@ -6,7 +6,6 @@ type Position int
const (
Start Position = iota
End
Slash
Colon
SemiColon
AltEnd

151
pkg/token/position_string.go
View File

@ -10,85 +10,84 @@ func _() {
var x [1]struct{}
_ = x[Start-0]
_ = x[End-1]
_ = x[Slash-2]
_ = x[Colon-3]
_ = x[SemiColon-4]
_ = x[AltEnd-5]
_ = x[Dollar-6]
_ = x[Ampersand-7]
_ = x[Name-8]
_ = x[Prefix-9]
_ = x[Key-10]
_ = x[Var-11]
_ = x[UseType-12]
_ = x[ReturnType-13]
_ = x[OptionalType-14]
_ = x[CaseSeparator-15]
_ = x[LexicalVars-16]
_ = x[Params-17]
_ = x[Ref-18]
_ = x[Cast-19]
_ = x[Expr-20]
_ = x[InitExpr-21]
_ = x[CondExpr-22]
_ = x[IncExpr-23]
_ = x[True-24]
_ = x[Cond-25]
_ = x[HaltCompiller-26]
_ = x[Namespace-27]
_ = x[Static-28]
_ = x[Class-29]
_ = x[Use-30]
_ = x[While-31]
_ = x[For-32]
_ = x[Switch-33]
_ = x[Break-34]
_ = x[Foreach-35]
_ = x[Declare-36]
_ = x[Label-37]
_ = x[Finally-38]
_ = x[List-39]
_ = x[Default-40]
_ = x[If-41]
_ = x[ElseIf-42]
_ = x[Else-43]
_ = x[Variadic-44]
_ = x[Function-45]
_ = x[DoubleArrow-46]
_ = x[Alias-47]
_ = x[As-48]
_ = x[Equal-49]
_ = x[Exit-50]
_ = x[Array-51]
_ = x[Isset-52]
_ = x[Empty-53]
_ = x[Eval-54]
_ = x[Echo-55]
_ = x[Try-56]
_ = x[Catch-57]
_ = x[Unset-58]
_ = x[Stmts-59]
_ = x[VarList-60]
_ = x[ConstList-61]
_ = x[NameList-62]
_ = x[ParamList-63]
_ = x[ModifierList-64]
_ = x[ArrayPairList-65]
_ = x[CaseListStart-66]
_ = x[CaseListEnd-67]
_ = x[ArgumentList-68]
_ = x[PropertyList-69]
_ = x[ParameterList-70]
_ = x[AdaptationList-71]
_ = x[LexicalVarList-72]
_ = x[UseDeclarationList-73]
_ = x[OpenParenthesisToken-74]
_ = x[CloseParenthesisToken-75]
_ = x[Colon-2]
_ = x[SemiColon-3]
_ = x[AltEnd-4]
_ = x[Dollar-5]
_ = x[Ampersand-6]
_ = x[Name-7]
_ = x[Prefix-8]
_ = x[Key-9]
_ = x[Var-10]
_ = x[UseType-11]
_ = x[ReturnType-12]
_ = x[OptionalType-13]
_ = x[CaseSeparator-14]
_ = x[LexicalVars-15]
_ = x[Params-16]
_ = x[Ref-17]
_ = x[Cast-18]
_ = x[Expr-19]
_ = x[InitExpr-20]
_ = x[CondExpr-21]
_ = x[IncExpr-22]
_ = x[True-23]
_ = x[Cond-24]
_ = x[HaltCompiller-25]
_ = x[Namespace-26]
_ = x[Static-27]
_ = x[Class-28]
_ = x[Use-29]
_ = x[While-30]
_ = x[For-31]
_ = x[Switch-32]
_ = x[Break-33]
_ = x[Foreach-34]
_ = x[Declare-35]
_ = x[Label-36]
_ = x[Finally-37]
_ = x[List-38]
_ = x[Default-39]
_ = x[If-40]
_ = x[ElseIf-41]
_ = x[Else-42]
_ = x[Variadic-43]
_ = x[Function-44]
_ = x[DoubleArrow-45]
_ = x[Alias-46]
_ = x[As-47]
_ = x[Equal-48]
_ = x[Exit-49]
_ = x[Array-50]
_ = x[Isset-51]
_ = x[Empty-52]
_ = x[Eval-53]
_ = x[Echo-54]
_ = x[Try-55]
_ = x[Catch-56]
_ = x[Unset-57]
_ = x[Stmts-58]
_ = x[VarList-59]
_ = x[ConstList-60]
_ = x[NameList-61]
_ = x[ParamList-62]
_ = x[ModifierList-63]
_ = x[ArrayPairList-64]
_ = x[CaseListStart-65]
_ = x[CaseListEnd-66]
_ = x[ArgumentList-67]
_ = x[PropertyList-68]
_ = x[ParameterList-69]
_ = x[AdaptationList-70]
_ = x[LexicalVarList-71]
_ = x[UseDeclarationList-72]
_ = x[OpenParenthesisToken-73]
_ = x[CloseParenthesisToken-74]
}
const _Position_name = "StartEndSlashColonSemiColonAltEndDollarAmpersandNamePrefixKeyVarUseTypeReturnTypeOptionalTypeCaseSeparatorLexicalVarsParamsRefCastExprInitExprCondExprIncExprTrueCondHaltCompillerNamespaceStaticClassUseWhileForSwitchBreakForeachDeclareLabelFinallyListDefaultIfElseIfElseVariadicFunctionDoubleArrowAliasAsEqualExitArrayIssetEmptyEvalEchoTryCatchUnsetStmtsVarListConstListNameListParamListModifierListArrayPairListCaseListStartCaseListEndArgumentListPropertyListParameterListAdaptationListLexicalVarListUseDeclarationListOpenParenthesisTokenCloseParenthesisToken"
const _Position_name = "StartEndColonSemiColonAltEndDollarAmpersandNamePrefixKeyVarUseTypeReturnTypeOptionalTypeCaseSeparatorLexicalVarsParamsRefCastExprInitExprCondExprIncExprTrueCondHaltCompillerNamespaceStaticClassUseWhileForSwitchBreakForeachDeclareLabelFinallyListDefaultIfElseIfElseVariadicFunctionDoubleArrowAliasAsEqualExitArrayIssetEmptyEvalEchoTryCatchUnsetStmtsVarListConstListNameListParamListModifierListArrayPairListCaseListStartCaseListEndArgumentListPropertyListParameterListAdaptationListLexicalVarListUseDeclarationListOpenParenthesisTokenCloseParenthesisToken"
var _Position_index = [...]uint16{0, 5, 8, 13, 18, 27, 33, 39, 48, 52, 58, 61, 64, 71, 81, 93, 106, 117, 123, 126, 130, 134, 142, 150, 157, 161, 165, 178, 187, 193, 198, 201, 206, 209, 215, 220, 227, 234, 239, 246, 250, 257, 259, 265, 269, 277, 285, 296, 301, 303, 308, 312, 317, 322, 327, 331, 335, 338, 343, 348, 353, 360, 369, 377, 386, 398, 411, 424, 435, 447, 459, 472, 486, 500, 518, 538, 559}
var _Position_index = [...]uint16{0, 5, 8, 13, 22, 28, 34, 43, 47, 53, 56, 59, 66, 76, 88, 101, 112, 118, 121, 125, 129, 137, 145, 152, 156, 160, 173, 182, 188, 193, 196, 201, 204, 210, 215, 222, 229, 234, 241, 245, 252, 254, 260, 264, 272, 280, 291, 296, 298, 303, 307, 312, 317, 322, 326, 330, 333, 338, 343, 348, 355, 364, 372, 381, 393, 406, 419, 430, 442, 454, 467, 481, 495, 513, 533, 554}
func (i Position) String() string {
if i < 0 || i >= Position(len(_Position_index)-1) {