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

#25: save position within node

Browse Source
This commit is contained in:
z7zmey
2018-06-24 10:19:44 +03:00
parent 6ac67675d5
commit 1ebb0c6fad
268 changed files with 53606 additions and 7719 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
parser/parser.go
View File

@@ -12,5 +12,4 @@ type Parser interface {
GetRootNode() node.Node
GetErrors() []*errors.Error
GetComments() Comments
GetPositions() Positions
}

178
parser/position_builder.go
View File

@@ -1,18 +1,13 @@
package parser
import (
"sync"
"github.com/z7zmey/php-parser/node"
"github.com/z7zmey/php-parser/position"
"github.com/z7zmey/php-parser/scanner"
)
// PositionBuilder provide functions to constuct positions
type PositionBuilder struct {
Positions *Positions
PositionPool *sync.Pool
}
type PositionBuilder struct{}
type startPos struct {
startLine int
@@ -44,7 +39,7 @@ func (b *PositionBuilder) getNodeStartPos(n node.Node) startPos {
return startPos{-1, -1}
}
p := (*b.Positions)[n]
p := n.GetPosition()
if p != nil {
sl = p.StartLine
sp = p.StartPos
@@ -73,7 +68,7 @@ func (b *PositionBuilder) getNodeEndPos(n node.Node) endPos {
return endPos{-1, -1}
}
p := (*b.Positions)[n]
p := n.GetPosition()
if p != nil {
el = p.EndLine
ep = p.EndPos
@@ -84,140 +79,129 @@ func (b *PositionBuilder) getNodeEndPos(n node.Node) endPos {
// NewNodeListPosition returns new Position
func (b *PositionBuilder) NewNodeListPosition(list []node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getListStartPos(list).startLine
pos.EndLine = b.getListEndPos(list).endLine
pos.StartPos = b.getListStartPos(list).startPos
pos.EndPos = b.getListEndPos(list).endPos
return pos
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: b.getListEndPos(list).endPos,
}
}
// NewNodePosition returns new Position
func (b *PositionBuilder) NewNodePosition(n node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getNodeStartPos(n).startLine
pos.EndLine = b.getNodeEndPos(n).endLine
pos.StartPos = b.getNodeStartPos(n).startPos
pos.EndPos = b.getNodeEndPos(n).endPos
return pos
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: b.getNodeEndPos(n).endPos,
}
}
// NewTokenPosition returns new Position
func (b *PositionBuilder) NewTokenPosition(t *scanner.Token) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = t.Position.StartLine
pos.EndLine = t.Position.EndLine
pos.StartPos = t.Position.StartPos
pos.EndPos = t.Position.EndPos
return pos
return &position.Position{
StartLine: t.StartLine,
EndLine: t.EndLine,
StartPos: t.StartPos,
EndPos: t.EndPos,
}
}
// NewTokensPosition returns new Position
func (b *PositionBuilder) NewTokensPosition(startToken *scanner.Token, endToken *scanner.Token) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = startToken.Position.StartLine
pos.EndLine = endToken.Position.EndLine
pos.StartPos = startToken.Position.StartPos
pos.EndPos = endToken.Position.EndPos
return pos
return &position.Position{
StartLine: startToken.StartLine,
EndLine: endToken.EndLine,
StartPos: startToken.StartPos,
EndPos: endToken.EndPos,
}
}
// NewTokenNodePosition returns new Position
func (b *PositionBuilder) NewTokenNodePosition(t *scanner.Token, n node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = t.Position.StartLine
pos.EndLine = b.getNodeEndPos(n).endLine
pos.StartPos = t.Position.StartPos
pos.EndPos = b.getNodeEndPos(n).endPos
return pos
return &position.Position{
StartLine: t.StartLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: t.StartPos,
EndPos: b.getNodeEndPos(n).endPos,
}
}
// NewNodeTokenPosition returns new Position
func (b *PositionBuilder) NewNodeTokenPosition(n node.Node, t *scanner.Token) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getNodeStartPos(n).startLine
pos.EndLine = t.Position.EndLine
pos.StartPos = b.getNodeStartPos(n).startPos
pos.EndPos = t.Position.EndPos
return pos
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: t.EndLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: t.EndPos,
}
}
// NewNodesPosition returns new Position
func (b *PositionBuilder) NewNodesPosition(startNode node.Node, endNode node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getNodeStartPos(startNode).startLine
pos.EndLine = b.getNodeEndPos(endNode).endLine
pos.StartPos = b.getNodeStartPos(startNode).startPos
pos.EndPos = b.getNodeEndPos(endNode).endPos
return pos
return &position.Position{
StartLine: b.getNodeStartPos(startNode).startLine,
EndLine: b.getNodeEndPos(endNode).endLine,
StartPos: b.getNodeStartPos(startNode).startPos,
EndPos: b.getNodeEndPos(endNode).endPos,
}
}
// NewNodeListTokenPosition returns new Position
func (b *PositionBuilder) NewNodeListTokenPosition(list []node.Node, t *scanner.Token) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getListStartPos(list).startLine
pos.EndLine = t.Position.EndLine
pos.StartPos = b.getListStartPos(list).startPos
pos.EndPos = t.Position.EndPos
return pos
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: t.EndLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: t.EndPos,
}
}
// NewTokenNodeListPosition returns new Position
func (b *PositionBuilder) NewTokenNodeListPosition(t *scanner.Token, list []node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = t.Position.StartLine
pos.EndLine = b.getListEndPos(list).endLine
pos.StartPos = t.Position.StartPos
pos.EndPos = b.getListEndPos(list).endPos
return pos
return &position.Position{
StartLine: t.StartLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: t.StartPos,
EndPos: b.getListEndPos(list).endPos,
}
}
// NewNodeNodeListPosition returns new Position
func (b *PositionBuilder) NewNodeNodeListPosition(n node.Node, list []node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getNodeStartPos(n).startLine
pos.EndLine = b.getListEndPos(list).endLine
pos.StartPos = b.getNodeStartPos(n).startPos
pos.EndPos = b.getListEndPos(list).endPos
return pos
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: b.getListEndPos(list).endPos,
}
}
// NewNodeListNodePosition returns new Position
func (b *PositionBuilder) NewNodeListNodePosition(list []node.Node, n node.Node) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
pos.StartLine = b.getListStartPos(list).startLine
pos.EndLine = b.getNodeEndPos(n).endLine
pos.StartPos = b.getListStartPos(list).startPos
pos.EndPos = b.getNodeEndPos(n).endPos
return pos
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: b.getNodeEndPos(n).endPos,
}
}
// NewOptionalListTokensPosition returns new Position
func (b *PositionBuilder) NewOptionalListTokensPosition(list []node.Node, t *scanner.Token, endToken *scanner.Token) *position.Position {
pos := b.PositionPool.Get().(*position.Position)
if list == nil {
pos.StartLine = t.Position.StartLine
pos.EndLine = endToken.Position.EndLine
pos.StartPos = t.Position.StartPos
pos.EndPos = endToken.Position.EndPos
return pos
return &position.Position{
StartLine: t.StartLine,
EndLine: endToken.EndLine,
StartPos: t.StartPos,
EndPos: endToken.EndPos,
}
}
pos.StartLine = b.getListStartPos(list).startLine
pos.EndLine = endToken.Position.EndLine
pos.StartPos = b.getListStartPos(list).startPos
pos.EndPos = endToken.Position.EndPos
return pos
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: endToken.EndLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: endToken.EndPos,
}
}

497
parser/position_builder_test.go
View File

@@ -1,7 +1,6 @@
package parser_test
import (
"sync"
"testing"
"github.com/z7zmey/php-parser/node"
@@ -12,16 +11,14 @@ import (
)
func TestNewTokenPosition(t *testing.T) {
builder := parser.PositionBuilder{
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
tpos := position.NewPosition(1, 1, 0, 3)
tkn := &scanner.Token{
Value: `foo`,
Position: tpos,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
pos := builder.NewTokenPosition(tkn)
@@ -32,21 +29,21 @@ func TestNewTokenPosition(t *testing.T) {
}
func TestNewTokensPosition(t *testing.T) {
builder := parser.PositionBuilder{
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
tpos1 := position.NewPosition(1, 1, 0, 3)
token1 := &scanner.Token{
Value: `foo`,
Position: tpos1,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
tpos2 := position.NewPosition(2, 2, 4, 6)
token2 := &scanner.Token{
Value: `foo`,
Position: tpos2,
Value: `foo`,
StartLine: 2,
EndLine: 2,
StartPos: 4,
EndPos: 6,
}
pos := builder.NewTokensPosition(token1, token2)
@@ -58,21 +55,14 @@ func TestNewTokensPosition(t *testing.T) {
func TestNewNodePosition(t *testing.T) {
n := node.NewIdentifier("test node")
p := &parser.Positions{}
p.AddPosition(n, &position.Position{
n.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
})
builder := parser.PositionBuilder{
Positions: p,
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodePosition(n)
@@ -82,27 +72,22 @@ func TestNewNodePosition(t *testing.T) {
}
func TestNewTokenNodePosition(t *testing.T) {
tpos := position.NewPosition(1, 1, 0, 3)
tkn := &scanner.Token{
Value: `foo`,
Position: tpos,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
n := node.NewIdentifier("test node")
p := &parser.Positions{}
p.AddPosition(n, &position.Position{
n.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 4,
EndPos: 12,
})
builder := parser.PositionBuilder{
Positions: p,
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewTokenNodePosition(tkn, n)
@@ -113,27 +98,23 @@ func TestNewTokenNodePosition(t *testing.T) {
func TestNewNodeTokenPosition(t *testing.T) {
n := node.NewIdentifier("test node")
tpos := position.NewPosition(2, 2, 10, 12)
tkn := &scanner.Token{
Value: `foo`,
Position: tpos,
}
p := &parser.Positions{}
p.AddPosition(n, &position.Position{
n.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
builder := parser.PositionBuilder{
Positions: p,
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
tkn := &scanner.Token{
Value: `foo`,
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 12,
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeTokenPosition(n, tkn)
if pos.String() != `Pos{Line: 1-2 Pos: 0-12}` {
@@ -143,27 +124,22 @@ func TestNewNodeTokenPosition(t *testing.T) {
func TestNewNodeListPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n2 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
},
n2: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeListPosition([]node.Node{n1, n2})
@@ -174,27 +150,22 @@ func TestNewNodeListPosition(t *testing.T) {
func TestNewNodesPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n2 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
},
n2: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodesPosition(n1, n2)
@@ -205,32 +176,30 @@ func TestNewNodesPosition(t *testing.T) {
func TestNewNodeListTokenPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
})
n2 := node.NewIdentifier("test node")
tpos := position.NewPosition(3, 3, 20, 22)
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
})
tkn := &scanner.Token{
Value: `foo`,
Position: tpos,
Value: `foo`,
StartLine: 3,
EndLine: 3,
StartPos: 20,
EndPos: 22,
}
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 9,
},
n2: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 10,
EndPos: 19,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListTokenPosition([]node.Node{n1, n2}, tkn)
@@ -240,33 +209,31 @@ func TestNewNodeListTokenPosition(t *testing.T) {
}
func TestNewTokenNodeListPosition(t *testing.T) {
tpos := position.NewPosition(1, 1, 0, 2)
tkn := &scanner.Token{
Value: `foo`,
Position: tpos,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 2,
}
n1 := node.NewIdentifier("test node")
n2 := node.NewIdentifier("test node")
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 3,
EndPos: 10,
},
n2: &position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 11,
EndPos: 20,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 3,
EndPos: 10,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 11,
EndPos: 20,
})
builder := parser.PositionBuilder{}
pos := builder.NewTokenNodeListPosition(tkn, []node.Node{n1, n2})
@@ -277,34 +244,30 @@ func TestNewTokenNodeListPosition(t *testing.T) {
func TestNewNodeNodeListPosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n2 := node.NewIdentifier("test node")
n3 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
},
n2: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
},
n3: &position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
})
n3 := node.NewIdentifier("test node")
n3.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
})
builder := parser.PositionBuilder{}
pos := builder.NewNodeNodeListPosition(n1, []node.Node{n2, n3})
@@ -315,34 +278,28 @@ func TestNewNodeNodeListPosition(t *testing.T) {
func TestNewNodeListNodePosition(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
})
n3 := node.NewIdentifier("test node")
n3.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
},
n2: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
},
n3: &position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListNodePosition([]node.Node{n1, n2}, n3)
@@ -352,21 +309,21 @@ func TestNewNodeListNodePosition(t *testing.T) {
}
func TestNewOptionalListTokensPosition(t *testing.T) {
builder := parser.PositionBuilder{
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
tpos1 := position.NewPosition(1, 1, 0, 3)
token1 := &scanner.Token{
Value: `foo`,
Position: tpos1,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
tpos2 := position.NewPosition(2, 2, 4, 6)
token2 := &scanner.Token{
Value: `foo`,
Position: tpos2,
Value: `foo`,
StartLine: 2,
EndLine: 2,
StartPos: 4,
EndPos: 6,
}
pos := builder.NewOptionalListTokensPosition(nil, token1, token2)
@@ -378,44 +335,42 @@ func TestNewOptionalListTokensPosition(t *testing.T) {
func TestNewOptionalListTokensPosition2(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
n2 := node.NewIdentifier("test node")
n2.SetPosition(&position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
})
n3 := node.NewIdentifier("test node")
n3.SetPosition(&position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
},
n2: &position.Position{
StartLine: 2,
EndLine: 2,
StartPos: 9,
EndPos: 17,
},
n3: &position.Position{
StartLine: 3,
EndLine: 3,
StartPos: 18,
EndPos: 26,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
tpos1 := position.NewPosition(4, 4, 27, 29)
token1 := &scanner.Token{
Value: `foo`,
Position: tpos1,
Value: `foo`,
StartLine: 4,
EndLine: 4,
StartPos: 27,
EndPos: 29,
}
tpos2 := position.NewPosition(5, 5, 30, 32)
token2 := &scanner.Token{
Value: `foo`,
Position: tpos2,
Value: `foo`,
StartLine: 5,
EndLine: 5,
StartPos: 30,
EndPos: 32,
}
pos := builder.NewOptionalListTokensPosition([]node.Node{n2, n3}, token1, token2)
@@ -426,11 +381,7 @@ func TestNewOptionalListTokensPosition2(t *testing.T) {
}
func TestNilNodePos(t *testing.T) {
builder := parser.PositionBuilder{
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodesPosition(nil, nil)
@@ -441,20 +392,14 @@ func TestNilNodePos(t *testing.T) {
func TestNilNodeListPos(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeNodeListPosition(n1, nil)
@@ -464,17 +409,15 @@ func TestNilNodeListPos(t *testing.T) {
}
func TestNilNodeListTokenPos(t *testing.T) {
tpos := position.NewPosition(1, 1, 0, 3)
token := &scanner.Token{
Value: `foo`,
Position: tpos,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
builder := parser.PositionBuilder{
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListTokenPosition(nil, token)
@@ -485,20 +428,14 @@ func TestNilNodeListTokenPos(t *testing.T) {
func TestEmptyNodeListPos(t *testing.T) {
n1 := node.NewIdentifier("test node")
n1.SetPosition(&position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
})
builder := parser.PositionBuilder{
Positions: &parser.Positions{
n1: &position.Position{
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 8,
},
},
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeNodeListPosition(n1, []node.Node{})
@@ -508,17 +445,15 @@ func TestEmptyNodeListPos(t *testing.T) {
}
func TestEmptyNodeListTokenPos(t *testing.T) {
tpos := position.NewPosition(1, 1, 0, 3)
token := &scanner.Token{
Value: `foo`,
Position: tpos,
Value: `foo`,
StartLine: 1,
EndLine: 1,
StartPos: 0,
EndPos: 3,
}
builder := parser.PositionBuilder{
PositionPool: &sync.Pool{
New: func() interface{} { return &position.Position{} },
},
}
builder := parser.PositionBuilder{}
pos := builder.NewNodeListTokenPosition([]node.Node{}, token)

14
parser/positions.go
View File

@@ -1,14 +0,0 @@
package parser
import (
"github.com/z7zmey/php-parser/node"
"github.com/z7zmey/php-parser/position"
)
// Positions a collection of positions attached to nodes
type Positions map[node.Node]*position.Position
// AddPosition attaches a position to a node
func (p Positions) AddPosition(node node.Node, position *position.Position) {
p[node] = position
}

25
parser/positions_test.go
View File

@@ -1,25 +0,0 @@
package parser_test
import (
"testing"
"github.com/z7zmey/php-parser/position"
"github.com/z7zmey/php-parser/node"
"github.com/z7zmey/php-parser/parser"
)
func TestPositions(t *testing.T) {
n := node.NewIdentifier("test")
expected := position.NewPosition(0, 0, 0, 0)
positions := parser.Positions{}
positions.AddPosition(n, expected)
actual := positions[n]
if actual != expected {
t.Errorf("expected and actual are not equal\n")
}
}