refactoring: create "ScalarEncapsedStringVar" node

pkg/ast/ast.go

@@ -175,6 +175,7 @@ type NodeVisitor interface {
 	ScalarDnumber(n *ScalarDnumber)
 	ScalarEncapsed(n *ScalarEncapsed)
 	ScalarEncapsedStringPart(n *ScalarEncapsedStringPart)
+	ScalarEncapsedStringVar(n *ScalarEncapsedStringVar)
 	ScalarHeredoc(n *ScalarHeredoc)
 	ScalarLnumber(n *ScalarLnumber)
 	ScalarMagicConstant(n *ScalarMagicConstant)

pkg/ast/node.go

@@ -131,6 +131,25 @@ func (n *ScalarEncapsedStringPart) GetPosition() *position.Position {
 	return n.Position
 }
 
+// ScalarEncapsedStringVar node
+type ScalarEncapsedStringVar struct {
+	Position                  *position.Position
+	DollarOpenCurlyBracketTkn *token.Token
+	VarName                   Vertex
+	OpenSquareBracketTkn      *token.Token
+	Dim                       Vertex
+	CloseSquareBracketTkn     *token.Token
+	CloseCurlyBracketTkn      *token.Token
+}
+
+func (n *ScalarEncapsedStringVar) Accept(v NodeVisitor) {
+	v.ScalarEncapsedStringVar(n)
+}
+
+func (n *ScalarEncapsedStringVar) GetPosition() *position.Position {
+	return n.Position
+}
+
 // ScalarHeredoc node
 type ScalarHeredoc struct {
 	Position        *position.Position

pkg/ast/traverser/dfs.go

@@ -2455,6 +2455,23 @@ func (t *DFS) Traverse(n ast.Vertex) {
 		if !t.visitor.EnterNode(nn) {
 			return
 		}
+	case *ast.ScalarEncapsedStringVar:
+		if nn == nil {
+			return
+		}
+		if !t.visitor.EnterNode(nn) {
+			return
+		}
+		if nn.VarName != nil {
+			t.visitor.Enter("VarName", true)
+			t.Traverse(nn.VarName)
+			t.visitor.Leave("VarName", true)
+		}
+		if nn.Dim != nil {
+			t.visitor.Enter("Dim", true)
+			t.Traverse(nn.Dim)
+			t.visitor.Leave("Dim", true)
+		}
 	case *ast.ScalarHeredoc:
 		if nn == nil {
 			return

pkg/ast/visitor/dumper.go

@@ -2258,6 +2258,22 @@ func (v *Dumper) ScalarEncapsedStringPart(n *ast.ScalarEncapsedStringPart) {
 	v.print(v.indent, "},\n")
 }
 
+func (v *Dumper) ScalarEncapsedStringVar(n *ast.ScalarEncapsedStringVar) {
+	v.print(0, "&ast.ScalarEncapsedStringVar{\n")
+	v.indent++
+
+	v.dumpPosition(n.Position)
+	v.dumpToken("DollarOpenCurlyBracketTkn", n.DollarOpenCurlyBracketTkn)
+	v.dumpVertex("VarName", n.VarName)
+	v.dumpToken("OpenSquareBracketTkn", n.OpenSquareBracketTkn)
+	v.dumpVertex("Dim", n.Dim)
+	v.dumpToken("CloseSquareBracketTkn", n.CloseSquareBracketTkn)
+	v.dumpToken("CloseCurlyBracketTkn", n.CloseCurlyBracketTkn)
+
+	v.indent--
+	v.print(v.indent, "},\n")
+}
+
 func (v *Dumper) ScalarHeredoc(n *ast.ScalarHeredoc) {
 	v.print(0, "&ast.ScalarHeredoc{\n")
 	v.indent++

pkg/ast/visitor/formatter.go

@@ -1970,6 +1970,21 @@ func (f *formatter) ScalarEncapsedStringPart(n *ast.ScalarEncapsedStringPart) {
 	}
 }
 
+func (f *formatter) ScalarEncapsedStringVar(n *ast.ScalarEncapsedStringVar) {
+	n.DollarOpenCurlyBracketTkn = f.newToken(token.T_DOLLAR_OPEN_CURLY_BRACES, []byte("${"))
+	n.VarName.Accept(f)
+
+	n.OpenSquareBracketTkn = nil
+	n.CloseSquareBracketTkn = nil
+	if n.Dim != nil {
+		n.OpenSquareBracketTkn = f.newToken('[', []byte("["))
+		n.Dim.Accept(f)
+		n.CloseSquareBracketTkn = f.newToken(']', []byte("]"))
+	}
+
+	n.CloseCurlyBracketTkn = f.newToken('}', []byte("}"))
+}
+
 func (f *formatter) ScalarHeredoc(n *ast.ScalarHeredoc) {
 	n.OpenHeredocTkn = f.newToken(token.T_START_HEREDOC, []byte("<<<EOT\n"))
 	for _, p := range n.Parts {

pkg/ast/visitor/formatter_test.go

@@ -6645,6 +6645,55 @@ func TestFormatter_ScalarEncapsedStringPart(t *testing.T) {
 	}
 }
 
+func TestFormatter_ScalarEncapsedStringVar(t *testing.T) {
+	o := bytes.NewBufferString("")
+
+	n := &ast.ScalarEncapsedStringVar{
+		VarName: &ast.Identifier{
+			Value: []byte("foo"),
+		},
+	}
+
+	f := visitor.NewFormatter().WithState(visitor.FormatterStatePHP).WithIndent(1)
+	n.Accept(f)
+
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n.Accept(p)
+
+	expected := `${foo}`
+	actual := o.String()
+
+	if expected != actual {
+		t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
+	}
+}
+
+func TestFormatter_ScalarEncapsedStringVar_Dim(t *testing.T) {
+	o := bytes.NewBufferString("")
+
+	n := &ast.ScalarEncapsedStringVar{
+		VarName: &ast.Identifier{
+			Value: []byte("foo"),
+		},
+		Dim: &ast.ScalarString{
+			Value: []byte("'bar'"),
+		},
+	}
+
+	f := visitor.NewFormatter().WithState(visitor.FormatterStatePHP).WithIndent(1)
+	n.Accept(f)
+
+	p := visitor.NewPrinter(o).WithState(visitor.PrinterStatePHP)
+	n.Accept(p)
+
+	expected := `${foo['bar']}`
+	actual := o.String()
+
+	if expected != actual {
+		t.Errorf("\nexpected: %s\ngot: %s\n", expected, actual)
+	}
+}
+
 func TestFormatter_ScalarHeredoc(t *testing.T) {
 	o := bytes.NewBufferString("")
 

pkg/ast/visitor/null.go

@@ -618,6 +618,10 @@ func (v *Null) ScalarEncapsedStringPart(_ *ast.ScalarEncapsedStringPart) {
 	// do nothing
 }
 
+func (v *Null) ScalarEncapsedStringVar(_ *ast.ScalarEncapsedStringVar) {
+	// do nothing
+}
+
 func (v *Null) ScalarHeredoc(_ *ast.ScalarHeredoc) {
 	// do nothing
 }

pkg/ast/visitor/printer.go

@@ -1199,6 +1199,15 @@ func (p *printer) ScalarEncapsedStringPart(n *ast.ScalarEncapsedStringPart) {
 	p.printToken(n.EncapsedStrTkn, n.Value)
 }
 
+func (p *printer) ScalarEncapsedStringVar(n *ast.ScalarEncapsedStringVar) {
+	p.printToken(n.DollarOpenCurlyBracketTkn, []byte("${"))
+	p.printNode(n.VarName)
+	p.printToken(n.OpenSquareBracketTkn, p.ifNode(n.Dim, []byte("[")))
+	p.printNode(n.Dim)
+	p.printToken(n.CloseSquareBracketTkn, p.ifNode(n.Dim, []byte("]")))
+	p.printToken(n.CloseCurlyBracketTkn, []byte("}"))
+}
+
 func (p *printer) ScalarHeredoc(n *ast.ScalarHeredoc) {
 	p.printToken(n.OpenHeredocTkn, []byte("<<<EOT\n"))
 	p.printList(n.Parts)