From d19b3f609ed8f1a8c6b81a9cca1e51424fba4c75 Mon Sep 17 00:00:00 2001 From: Vadym Slizov Date: Fri, 4 Dec 2020 10:40:48 +0200 Subject: [PATCH] [refactoring] update ast structure of "Assign" and "Binary" nodes --- internal/php5/php5.go | Bin 274372 -> 264006 bytes internal/php5/php5.y | 1085 ++++++++++++++++++++--------------------- internal/php7/php7.go | Bin 224287 -> 219046 bytes internal/php7/php7.y | 728 +++++++++++++-------------- pkg/ast/node.go | 103 ++-- 5 files changed, 972 insertions(+), 944 deletions(-) diff --git a/internal/php5/php5.go b/internal/php5/php5.go index 8664f6e873cc4c4c2334631f2933283cce0e1d19..58de3b2e1c6f46459be94bb3c6f2155036d8db7c 100644 GIT binary patch delta 8762 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 delta 11324 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 L?PTQdW{CMeYx-5= diff --git a/internal/php5/php5.y b/internal/php5/php5.y index 7ff468a..3f5ef26 100644 --- a/internal/php5/php5.y +++ b/internal/php5/php5.y @@ -3129,57 +3129,46 @@ new_expr: expr_without_variable: T_LIST '(' assignment_list ')' '=' expr { - pairList := $3.(*ast.ParserSeparatedList) - fistPair := pairList.Items[0].(*ast.ExprArrayItem) - - if fistPair.Key == nil && fistPair.Val == nil && len(pairList.Items) == 1 { - pairList.Items = nil - } - - listNode := &ast.ExprList{ + $$ = &ast.ExprAssign{ Node: ast.Node{ - Position: position.NewTokensPosition($1, $4), + Position: position.NewTokenNodePosition($1, $6), }, - ListTkn: $1, - OpenBracketTkn: $2, - Items: $3.(*ast.ParserSeparatedList).Items, - SeparatorTkns: $3.(*ast.ParserSeparatedList).SeparatorTkns, - CloseBracketTkn: $4, + Var: &ast.ExprList{ + Node: ast.Node{ + Position: position.NewTokensPosition($1, $4), + }, + ListTkn: $1, + OpenBracketTkn: $2, + Items: $3.(*ast.ParserSeparatedList).Items, + SeparatorTkns: $3.(*ast.ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $4, + }, + EqualTkn: $5, + Expr: $6, } - $$ = &ast.ExprAssign{ast.Node{}, listNode, $6} - - // save position - listNode.GetNode().Position = position.NewTokensPosition($1, $4) - $$.GetNode().Position = position.NewTokenNodePosition($1, $6) - - // save comments - yylex.(*Parser).setFreeFloating($$, token.Start, $1.SkippedTokens) - yylex.(*Parser).setFreeFloating(listNode, token.List, $2.SkippedTokens) - yylex.(*Parser).setFreeFloating(listNode, token.ArrayPairList, $4.SkippedTokens) - yylex.(*Parser).setFreeFloating($$, token.Var, $5.SkippedTokens) } | variable '=' expr { - $$ = &ast.ExprAssign{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssign{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable '=' '&' variable { - $$ = &ast.ExprAssignReference{ast.Node{}, $1, $4} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $4) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) - yylex.(*Parser).setFreeFloating($$, token.Equal, $3.SkippedTokens) + $$ = &ast.ExprAssignReference{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $4), + }, + Var: $1, + EqualTkn: $2, + AmpersandTkn: $3, + Expr: $4, + } } | variable '=' '&' T_NEW class_name_reference ctor_arguments { @@ -3205,21 +3194,15 @@ expr_without_variable: } } - $$ = &ast.ExprAssignReference{ast.Node{}, $1, _new} - - // save position - if $6 != nil { - _new.GetNode().Position = position.NewTokenNodePosition($4, $6) - } else { - _new.GetNode().Position = position.NewTokenNodePosition($4, $5) + $$ = &ast.ExprAssignReference{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, _new), + }, + Var: $1, + EqualTkn: $2, + AmpersandTkn: $3, + Expr: _new, } - $$.GetNode().Position = position.NewNodesPosition($1, _new) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) - yylex.(*Parser).setFreeFloating($$, token.Equal, $3.SkippedTokens) - yylex.(*Parser).setFreeFloating(_new, token.Start, $4.SkippedTokens) } | T_CLONE expr { @@ -3233,134 +3216,135 @@ expr_without_variable: } | variable T_PLUS_EQUAL expr { - $$ = &ast.ExprAssignPlus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignPlus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_MINUS_EQUAL expr { - $$ = &ast.ExprAssignMinus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignMinus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_MUL_EQUAL expr { - $$ = &ast.ExprAssignMul{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignMul{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_POW_EQUAL expr { - $$ = &ast.ExprAssignPow{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignPow{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_DIV_EQUAL expr { - $$ = &ast.ExprAssignDiv{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignDiv{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_CONCAT_EQUAL expr { - $$ = &ast.ExprAssignConcat{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignConcat{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_MOD_EQUAL expr { - $$ = &ast.ExprAssignMod{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignMod{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_AND_EQUAL expr { - $$ = &ast.ExprAssignBitwiseAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignBitwiseAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_OR_EQUAL expr { - $$ = &ast.ExprAssignBitwiseOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignBitwiseOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_XOR_EQUAL expr { - $$ = &ast.ExprAssignBitwiseXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignBitwiseXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_SL_EQUAL expr { - $$ = &ast.ExprAssignShiftLeft{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignShiftLeft{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_SR_EQUAL expr { - $$ = &ast.ExprAssignShiftRight{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignShiftRight{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | rw_variable T_INC { @@ -3404,189 +3388,190 @@ expr_without_variable: } | expr T_BOOLEAN_OR expr { - $$ = &ast.ExprBinaryBooleanOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBooleanOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_BOOLEAN_AND expr { - $$ = &ast.ExprBinaryBooleanAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBooleanAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_LOGICAL_OR expr { - $$ = &ast.ExprBinaryLogicalOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_LOGICAL_AND expr { - $$ = &ast.ExprBinaryLogicalAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_LOGICAL_XOR expr { - $$ = &ast.ExprBinaryLogicalXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '|' expr { - $$ = &ast.ExprBinaryBitwiseOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '&' expr { - $$ = &ast.ExprBinaryBitwiseAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '^' expr { - $$ = &ast.ExprBinaryBitwiseXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '.' expr { - $$ = &ast.ExprBinaryConcat{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryConcat{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '+' expr { - $$ = &ast.ExprBinaryPlus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryPlus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '-' expr { - $$ = &ast.ExprBinaryMinus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMinus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '*' expr { - $$ = &ast.ExprBinaryMul{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMul{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_POW expr { - $$ = &ast.ExprBinaryPow{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryPow{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '/' expr { - $$ = &ast.ExprBinaryDiv{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryDiv{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '%' expr { - $$ = &ast.ExprBinaryMod{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMod{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_SL expr { - $$ = &ast.ExprBinaryShiftLeft{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryShiftLeft{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_SR expr { - $$ = &ast.ExprBinaryShiftRight{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryShiftRight{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | '+' expr %prec T_INC { @@ -3630,92 +3615,92 @@ expr_without_variable: } | expr T_IS_IDENTICAL expr { - $$ = &ast.ExprBinaryIdentical{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryIdentical{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_NOT_IDENTICAL expr { - $$ = &ast.ExprBinaryNotIdentical{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryNotIdentical{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_EQUAL expr { - $$ = &ast.ExprBinaryEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_NOT_EQUAL expr { - $$ = &ast.ExprBinaryNotEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryNotEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } yylex.(*Parser).setToken($$, token.Equal, $2.SkippedTokens) } | expr '<' expr { - $$ = &ast.ExprBinarySmaller{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySmaller{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_SMALLER_OR_EQUAL expr { - $$ = &ast.ExprBinarySmallerOrEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySmallerOrEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '>' expr { - $$ = &ast.ExprBinaryGreater{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryGreater{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_GREATER_OR_EQUAL expr { - $$ = &ast.ExprBinaryGreaterOrEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryGreaterOrEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_INSTANCEOF class_name_reference { @@ -4838,69 +4823,69 @@ static_operation: } | static_scalar_value '+' static_scalar_value { - $$ = &ast.ExprBinaryPlus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryPlus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '-' static_scalar_value { - $$ = &ast.ExprBinaryMinus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMinus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '*' static_scalar_value { - $$ = &ast.ExprBinaryMul{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMul{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_POW static_scalar_value { - $$ = &ast.ExprBinaryPow{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryPow{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '/' static_scalar_value { - $$ = &ast.ExprBinaryDiv{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryDiv{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '%' static_scalar_value { - $$ = &ast.ExprBinaryMod{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMod{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | '!' static_scalar_value { @@ -4924,213 +4909,213 @@ static_operation: } | static_scalar_value '|' static_scalar_value { - $$ = &ast.ExprBinaryBitwiseOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '&' static_scalar_value { - $$ = &ast.ExprBinaryBitwiseAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '^' static_scalar_value { - $$ = &ast.ExprBinaryBitwiseXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_SL static_scalar_value { - $$ = &ast.ExprBinaryShiftLeft{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryShiftLeft{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_SR static_scalar_value { - $$ = &ast.ExprBinaryShiftRight{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryShiftRight{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '.' static_scalar_value { - $$ = &ast.ExprBinaryConcat{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryConcat{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_LOGICAL_XOR static_scalar_value { - $$ = &ast.ExprBinaryLogicalXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_LOGICAL_AND static_scalar_value { - $$ = &ast.ExprBinaryLogicalAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_LOGICAL_OR static_scalar_value { - $$ = &ast.ExprBinaryLogicalOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_BOOLEAN_AND static_scalar_value { - $$ = &ast.ExprBinaryBooleanAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBooleanAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_BOOLEAN_OR static_scalar_value { - $$ = &ast.ExprBinaryBooleanOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBooleanOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_IS_IDENTICAL static_scalar_value { - $$ = &ast.ExprBinaryIdentical{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryIdentical{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_IS_NOT_IDENTICAL static_scalar_value { - $$ = &ast.ExprBinaryNotIdentical{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryNotIdentical{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_IS_EQUAL static_scalar_value { - $$ = &ast.ExprBinaryEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_IS_NOT_EQUAL static_scalar_value { - $$ = &ast.ExprBinaryNotEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryNotEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } yylex.(*Parser).setToken($$, token.Equal, $2.SkippedTokens) } | static_scalar_value '<' static_scalar_value { - $$ = &ast.ExprBinarySmaller{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySmaller{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '>' static_scalar_value { - $$ = &ast.ExprBinaryGreater{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryGreater{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_IS_SMALLER_OR_EQUAL static_scalar_value { - $$ = &ast.ExprBinarySmallerOrEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySmallerOrEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value T_IS_GREATER_OR_EQUAL static_scalar_value { - $$ = &ast.ExprBinaryGreaterOrEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryGreaterOrEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | static_scalar_value '?' ':' static_scalar_value { diff --git a/internal/php7/php7.go b/internal/php7/php7.go index 8788ab26ffc89584dd54141cf98f8c93947dea7d..37040523cff8d26e06598ac596857d229308ba41 100644 GIT binary patch delta 8893 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 delta 9607 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 OL&OsmkTQl^dH)9Q(g&ab diff --git a/internal/php7/php7.y b/internal/php7/php7.y index 7390dd6..25adcd7 100644 --- a/internal/php7/php7.y +++ b/internal/php7/php7.y @@ -2804,65 +2804,65 @@ new_expr: expr_without_variable: T_LIST '(' array_pair_list ')' '=' expr { - listNode := &ast.ExprList{ + $$ = &ast.ExprAssign{ Node: ast.Node{ - Position: position.NewTokensPosition($1, $4), + Position: position.NewTokenNodePosition($1, $6), }, - ListTkn: $1, - OpenBracketTkn: $2, - Items: $3.(*ast.ParserSeparatedList).Items, - SeparatorTkns: $3.(*ast.ParserSeparatedList).SeparatorTkns, - CloseBracketTkn: $4, + Var: &ast.ExprList{ + Node: ast.Node{ + Position: position.NewTokensPosition($1, $4), + }, + ListTkn: $1, + OpenBracketTkn: $2, + Items: $3.(*ast.ParserSeparatedList).Items, + SeparatorTkns: $3.(*ast.ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $4, + }, + EqualTkn: $5, + Expr: $6, } - $$ = &ast.ExprAssign{ast.Node{}, listNode, $6} - - // save position - $$.GetNode().Position = position.NewTokenNodePosition($1, $6) - - // save comments - yylex.(*Parser).setFreeFloating($$, token.Var, $5.SkippedTokens) } | '[' array_pair_list ']' '=' expr { - listNode := &ast.ExprList{ + $$ = &ast.ExprAssign{ Node: ast.Node{ - Position: position.NewTokensPosition($1, $3), + Position: position.NewTokenNodePosition($1, $5), }, - OpenBracketTkn: $1, - Items: $2.(*ast.ParserSeparatedList).Items, - SeparatorTkns: $2.(*ast.ParserSeparatedList).SeparatorTkns, - CloseBracketTkn: $3, + Var: &ast.ExprList{ + Node: ast.Node{ + Position: position.NewTokensPosition($1, $3), + }, + OpenBracketTkn: $1, + Items: $2.(*ast.ParserSeparatedList).Items, + SeparatorTkns: $2.(*ast.ParserSeparatedList).SeparatorTkns, + CloseBracketTkn: $3, + }, + EqualTkn: $4, + Expr: $5, } - $$ = &ast.ExprAssign{ast.Node{}, listNode, $5} - - // save position - $$.GetNode().Position = position.NewTokenNodePosition($1, $5) - - // save comments - yylex.(*Parser).setFreeFloating($$, token.Var, $4.SkippedTokens) } | variable '=' expr { - $$ = &ast.ExprAssign{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssign{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable '=' '&' expr { - $$ = &ast.ExprAssignReference{ast.Node{}, $1, $4} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $4) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) - yylex.(*Parser).setFreeFloating($$, token.Equal, $3.SkippedTokens) + $$ = &ast.ExprAssignReference{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $4), + }, + Var: $1, + EqualTkn: $2, + AmpersandTkn: $3, + Expr: $4, + } } | T_CLONE expr { @@ -2876,146 +2876,146 @@ expr_without_variable: } | variable T_PLUS_EQUAL expr { - $$ = &ast.ExprAssignPlus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignPlus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_MINUS_EQUAL expr { - $$ = &ast.ExprAssignMinus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignMinus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_MUL_EQUAL expr { - $$ = &ast.ExprAssignMul{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignMul{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_POW_EQUAL expr { - $$ = &ast.ExprAssignPow{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignPow{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_DIV_EQUAL expr { - $$ = &ast.ExprAssignDiv{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignDiv{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_CONCAT_EQUAL expr { - $$ = &ast.ExprAssignConcat{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignConcat{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_MOD_EQUAL expr { - $$ = &ast.ExprAssignMod{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignMod{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_AND_EQUAL expr { - $$ = &ast.ExprAssignBitwiseAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignBitwiseAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_OR_EQUAL expr { - $$ = &ast.ExprAssignBitwiseOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignBitwiseOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_XOR_EQUAL expr { - $$ = &ast.ExprAssignBitwiseXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignBitwiseXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_SL_EQUAL expr { - $$ = &ast.ExprAssignShiftLeft{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignShiftLeft{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_SR_EQUAL expr { - $$ = &ast.ExprAssignShiftRight{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignShiftRight{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_COALESCE_EQUAL expr { - $$ = &ast.ExprAssignCoalesce{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Var, $2.SkippedTokens) + $$ = &ast.ExprAssignCoalesce{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Var: $1, + EqualTkn: $2, + Expr: $3, + } } | variable T_INC { @@ -3059,189 +3059,190 @@ expr_without_variable: } | expr T_BOOLEAN_OR expr { - $$ = &ast.ExprBinaryBooleanOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBooleanOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_BOOLEAN_AND expr { - $$ = &ast.ExprBinaryBooleanAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBooleanAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_LOGICAL_OR expr { - $$ = &ast.ExprBinaryLogicalOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_LOGICAL_AND expr { - $$ = &ast.ExprBinaryLogicalAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_LOGICAL_XOR expr { - $$ = &ast.ExprBinaryLogicalXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryLogicalXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '|' expr { - $$ = &ast.ExprBinaryBitwiseOr{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseOr{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '&' expr { - $$ = &ast.ExprBinaryBitwiseAnd{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseAnd{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '^' expr { - $$ = &ast.ExprBinaryBitwiseXor{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryBitwiseXor{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '.' expr { - $$ = &ast.ExprBinaryConcat{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryConcat{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '+' expr { - $$ = &ast.ExprBinaryPlus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryPlus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '-' expr { - $$ = &ast.ExprBinaryMinus{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMinus{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '*' expr { - $$ = &ast.ExprBinaryMul{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMul{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_POW expr { - $$ = &ast.ExprBinaryPow{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryPow{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '/' expr { - $$ = &ast.ExprBinaryDiv{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryDiv{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '%' expr { - $$ = &ast.ExprBinaryMod{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryMod{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_SL expr { - $$ = &ast.ExprBinaryShiftLeft{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryShiftLeft{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_SR expr { - $$ = &ast.ExprBinaryShiftRight{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryShiftRight{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | '+' expr %prec T_INC { @@ -3285,103 +3286,102 @@ expr_without_variable: } | expr T_IS_IDENTICAL expr { - $$ = &ast.ExprBinaryIdentical{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryIdentical{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_NOT_IDENTICAL expr { - $$ = &ast.ExprBinaryNotIdentical{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryNotIdentical{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_EQUAL expr { - $$ = &ast.ExprBinaryEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_NOT_EQUAL expr { - $$ = &ast.ExprBinaryNotEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) - yylex.(*Parser).setToken($$, token.Equal, $2.SkippedTokens) + $$ = &ast.ExprBinaryNotEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '<' expr { - $$ = &ast.ExprBinarySmaller{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySmaller{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_SMALLER_OR_EQUAL expr { - $$ = &ast.ExprBinarySmallerOrEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySmallerOrEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr '>' expr { - $$ = &ast.ExprBinaryGreater{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryGreater{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_IS_GREATER_OR_EQUAL expr { - $$ = &ast.ExprBinaryGreaterOrEqual{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryGreaterOrEqual{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_SPACESHIP expr { - $$ = &ast.ExprBinarySpaceship{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinarySpaceship{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | expr T_INSTANCEOF class_name_reference { @@ -3440,14 +3440,14 @@ expr_without_variable: } | expr T_COALESCE expr { - $$ = &ast.ExprBinaryCoalesce{ast.Node{}, $1, $3} - - // save position - $$.GetNode().Position = position.NewNodesPosition($1, $3) - - // save comments - yylex.(*Parser).MoveFreeFloating($1, $$) - yylex.(*Parser).setFreeFloating($$, token.Expr, $2.SkippedTokens) + $$ = &ast.ExprBinaryCoalesce{ + Node: ast.Node{ + Position: position.NewNodesPosition($1, $3), + }, + Left: $1, + OpTkn: $2, + Right: $3, + } } | internal_functions_in_yacc { diff --git a/pkg/ast/node.go b/pkg/ast/node.go index a4599b4..ccea997 100644 --- a/pkg/ast/node.go +++ b/pkg/ast/node.go @@ -1529,8 +1529,9 @@ func (n *ExprCastUnset) Accept(v NodeVisitor) { // ExprAssign node type ExprAssign struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssign) Accept(v NodeVisitor) { @@ -1540,8 +1541,10 @@ func (n *ExprAssign) Accept(v NodeVisitor) { // ExprAssignReference node type ExprAssignReference struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + AmpersandTkn *token.Token + Expr Vertex } func (n *ExprAssignReference) Accept(v NodeVisitor) { @@ -1551,8 +1554,9 @@ func (n *ExprAssignReference) Accept(v NodeVisitor) { // ExprAssignBitwiseAnd node type ExprAssignBitwiseAnd struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignBitwiseAnd) Accept(v NodeVisitor) { @@ -1562,8 +1566,9 @@ func (n *ExprAssignBitwiseAnd) Accept(v NodeVisitor) { // ExprAssignBitwiseOr node type ExprAssignBitwiseOr struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignBitwiseOr) Accept(v NodeVisitor) { @@ -1573,8 +1578,9 @@ func (n *ExprAssignBitwiseOr) Accept(v NodeVisitor) { // ExprAssignBitwiseXor node type ExprAssignBitwiseXor struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignBitwiseXor) Accept(v NodeVisitor) { @@ -1584,8 +1590,9 @@ func (n *ExprAssignBitwiseXor) Accept(v NodeVisitor) { // ExprAssignCoalesce node type ExprAssignCoalesce struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignCoalesce) Accept(v NodeVisitor) { @@ -1595,8 +1602,9 @@ func (n *ExprAssignCoalesce) Accept(v NodeVisitor) { // ExprAssignConcat node type ExprAssignConcat struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignConcat) Accept(v NodeVisitor) { @@ -1606,8 +1614,9 @@ func (n *ExprAssignConcat) Accept(v NodeVisitor) { // ExprAssignDiv node type ExprAssignDiv struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignDiv) Accept(v NodeVisitor) { @@ -1617,8 +1626,9 @@ func (n *ExprAssignDiv) Accept(v NodeVisitor) { // ExprAssignMinus node type ExprAssignMinus struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignMinus) Accept(v NodeVisitor) { @@ -1628,8 +1638,9 @@ func (n *ExprAssignMinus) Accept(v NodeVisitor) { // ExprAssignMod node type ExprAssignMod struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignMod) Accept(v NodeVisitor) { @@ -1639,8 +1650,9 @@ func (n *ExprAssignMod) Accept(v NodeVisitor) { // ExprAssignMul node type ExprAssignMul struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignMul) Accept(v NodeVisitor) { @@ -1650,8 +1662,9 @@ func (n *ExprAssignMul) Accept(v NodeVisitor) { // ExprAssignPlus node type ExprAssignPlus struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignPlus) Accept(v NodeVisitor) { @@ -1661,8 +1674,9 @@ func (n *ExprAssignPlus) Accept(v NodeVisitor) { // ExprAssignPow node type ExprAssignPow struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignPow) Accept(v NodeVisitor) { @@ -1672,8 +1686,9 @@ func (n *ExprAssignPow) Accept(v NodeVisitor) { // ExprAssignShiftLeft node type ExprAssignShiftLeft struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignShiftLeft) Accept(v NodeVisitor) { @@ -1683,8 +1698,9 @@ func (n *ExprAssignShiftLeft) Accept(v NodeVisitor) { // ExprAssignShiftRight node type ExprAssignShiftRight struct { Node - Var Vertex - Expr Vertex + Var Vertex + EqualTkn *token.Token + Expr Vertex } func (n *ExprAssignShiftRight) Accept(v NodeVisitor) { @@ -1695,6 +1711,7 @@ func (n *ExprAssignShiftRight) Accept(v NodeVisitor) { type ExprBinaryBitwiseAnd struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1706,6 +1723,7 @@ func (n *ExprBinaryBitwiseAnd) Accept(v NodeVisitor) { type ExprBinaryBitwiseOr struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1717,6 +1735,7 @@ func (n *ExprBinaryBitwiseOr) Accept(v NodeVisitor) { type ExprBinaryBitwiseXor struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1728,6 +1747,7 @@ func (n *ExprBinaryBitwiseXor) Accept(v NodeVisitor) { type ExprBinaryBooleanAnd struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1739,6 +1759,7 @@ func (n *ExprBinaryBooleanAnd) Accept(v NodeVisitor) { type ExprBinaryBooleanOr struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1750,6 +1771,7 @@ func (n *ExprBinaryBooleanOr) Accept(v NodeVisitor) { type ExprBinaryCoalesce struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1761,6 +1783,7 @@ func (n *ExprBinaryCoalesce) Accept(v NodeVisitor) { type ExprBinaryConcat struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1772,6 +1795,7 @@ func (n *ExprBinaryConcat) Accept(v NodeVisitor) { type ExprBinaryDiv struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1783,6 +1807,7 @@ func (n *ExprBinaryDiv) Accept(v NodeVisitor) { type ExprBinaryEqual struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1794,6 +1819,7 @@ func (n *ExprBinaryEqual) Accept(v NodeVisitor) { type ExprBinaryGreater struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1805,6 +1831,7 @@ func (n *ExprBinaryGreater) Accept(v NodeVisitor) { type ExprBinaryGreaterOrEqual struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1816,6 +1843,7 @@ func (n *ExprBinaryGreaterOrEqual) Accept(v NodeVisitor) { type ExprBinaryIdentical struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1827,6 +1855,7 @@ func (n *ExprBinaryIdentical) Accept(v NodeVisitor) { type ExprBinaryLogicalAnd struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1838,6 +1867,7 @@ func (n *ExprBinaryLogicalAnd) Accept(v NodeVisitor) { type ExprBinaryLogicalOr struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1849,6 +1879,7 @@ func (n *ExprBinaryLogicalOr) Accept(v NodeVisitor) { type ExprBinaryLogicalXor struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1860,6 +1891,7 @@ func (n *ExprBinaryLogicalXor) Accept(v NodeVisitor) { type ExprBinaryMinus struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1871,6 +1903,7 @@ func (n *ExprBinaryMinus) Accept(v NodeVisitor) { type ExprBinaryMod struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1882,6 +1915,7 @@ func (n *ExprBinaryMod) Accept(v NodeVisitor) { type ExprBinaryMul struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1893,6 +1927,7 @@ func (n *ExprBinaryMul) Accept(v NodeVisitor) { type ExprBinaryNotEqual struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1904,6 +1939,7 @@ func (n *ExprBinaryNotEqual) Accept(v NodeVisitor) { type ExprBinaryNotIdentical struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1915,6 +1951,7 @@ func (n *ExprBinaryNotIdentical) Accept(v NodeVisitor) { type ExprBinaryPlus struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1926,6 +1963,7 @@ func (n *ExprBinaryPlus) Accept(v NodeVisitor) { type ExprBinaryPow struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1937,6 +1975,7 @@ func (n *ExprBinaryPow) Accept(v NodeVisitor) { type ExprBinaryShiftLeft struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1948,6 +1987,7 @@ func (n *ExprBinaryShiftLeft) Accept(v NodeVisitor) { type ExprBinaryShiftRight struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1959,6 +1999,7 @@ func (n *ExprBinaryShiftRight) Accept(v NodeVisitor) { type ExprBinarySmaller struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1970,6 +2011,7 @@ func (n *ExprBinarySmaller) Accept(v NodeVisitor) { type ExprBinarySmallerOrEqual struct { Node Left Vertex + OpTkn *token.Token Right Vertex } @@ -1981,6 +2023,7 @@ func (n *ExprBinarySmallerOrEqual) Accept(v NodeVisitor) { type ExprBinarySpaceship struct { Node Left Vertex + OpTkn *token.Token Right Vertex }