diff --git a/cmd/php-parser/main.go b/cmd/php-parser/main.go
index a94d348..796e87e 100644
--- a/cmd/php-parser/main.go
+++ b/cmd/php-parser/main.go
@@ -3,10 +3,7 @@ package main
 import (
 	"bytes"
 	"flag"
-	"github.com/z7zmey/php-parser/pkg/visitor/dumper"
-	"github.com/z7zmey/php-parser/pkg/visitor/nsresolver"
-	"github.com/z7zmey/php-parser/pkg/visitor/printer"
-	"github.com/z7zmey/php-parser/pkg/visitor/traverser"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"log"
@@ -21,15 +18,20 @@ import (
 	"github.com/yookoala/realpath"
 
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
 	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/parser"
+	"github.com/z7zmey/php-parser/pkg/version"
+	"github.com/z7zmey/php-parser/pkg/visitor/dumper"
+	"github.com/z7zmey/php-parser/pkg/visitor/nsresolver"
+	"github.com/z7zmey/php-parser/pkg/visitor/printer"
+	"github.com/z7zmey/php-parser/pkg/visitor/traverser"
 )
 
 var wg sync.WaitGroup
-var phpVersion string
+var phpVersion *version.Version
 var profiler string
 var dump *bool
-var withFreeFloating *bool
 var showResolvedNs *bool
 var printBack *bool
 var printPath *bool
@@ -49,19 +51,26 @@ type result struct {
 
 func main() {
 	start := time.Now()
+	var phpVer string
 
 	printExecTime = flag.Bool("time", false, "print execution time")
-	withFreeFloating = flag.Bool("ff", false, "parse and show free floating strings")
 	showResolvedNs = flag.Bool("r", false, "resolve names")
 	printBack = flag.Bool("pb", false, "print AST back into the parsed file")
 	printPath = flag.Bool("p", false, "print filepath")
 	printErrors = flag.Bool("e", false, "print errors")
 	dump = flag.Bool("d", false, "dump")
 	flag.StringVar(&profiler, "prof", "", "start profiler: [cpu, mem, trace]")
-	flag.StringVar(&phpVersion, "phpver", "7.4", "php version")
+	flag.StringVar(&phpVer, "phpver", "7.4", "php version")
 
 	flag.Parse()
 
+	var err error
+	phpVersion, err = version.New(phpVer)
+	if err != nil {
+		fmt.Println("Error: " + err.Error())
+		os.Exit(1)
+	}
+
 	if len(flag.Args()) == 0 {
 		flag.Usage()
 		return
@@ -128,16 +137,16 @@ func parserWorker(fileCh <-chan *file, r chan<- result) {
 			return
 		}
 
-		parserErrors := []*errors.Error{}
-		cfg := parser.Config{
-			WithTokens: *withFreeFloating,
+		var parserErrors []*errors.Error
+		rootNode, err := parser.Parse(f.content, cfg.Config{
+			Version: phpVersion,
 			ErrorHandlerFunc: func(e *errors.Error) {
 				parserErrors = append(parserErrors, e)
 			},
-		}
-		rootNode, err := parser.Parse(f.content, phpVersion, cfg)
+		})
 		if err != nil {
-			panic(err.Error())
+			fmt.Println("Error:" + err.Error())
+			os.Exit(1)
 		}
 
 		r <- result{path: f.path, rootNode: rootNode, errors: parserErrors}
diff --git a/internal/php5/parser.go b/internal/php5/parser.go
index 84015d2..a8c8dcf 100644
--- a/internal/php5/parser.go
+++ b/internal/php5/parser.go
@@ -1,9 +1,10 @@
 package php5
 
 import (
-	builder "github.com/z7zmey/php-parser/internal/position"
+	"github.com/z7zmey/php-parser/internal/position"
 	"github.com/z7zmey/php-parser/internal/scanner"
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
 	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/token"
 )
@@ -14,15 +15,15 @@ type Parser struct {
 	currentToken   *token.Token
 	rootNode       ast.Vertex
 	errHandlerFunc func(*errors.Error)
-	builder        *builder.Builder
+	builder        *position.Builder
 }
 
 // NewParser creates and returns new Parser
-func NewParser(lexer *scanner.Lexer, errHandlerFunc func(*errors.Error)) *Parser {
+func NewParser(lexer *scanner.Lexer, config cfg.Config) *Parser {
 	return &Parser{
 		Lexer:          lexer,
-		errHandlerFunc: errHandlerFunc,
-		builder:        builder.NewBuilder(),
+		errHandlerFunc: config.ErrorHandlerFunc,
+		builder:        position.NewBuilder(),
 	}
 }
 
diff --git a/internal/php5/parser_test.go b/internal/php5/parser_test.go
index 6c1dfde..a8a9bd5 100644
--- a/internal/php5/parser_test.go
+++ b/internal/php5/parser_test.go
@@ -8,9 +8,11 @@ import (
 	"github.com/z7zmey/php-parser/internal/php5"
 	"github.com/z7zmey/php-parser/internal/scanner"
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
 	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/position"
 	"github.com/z7zmey/php-parser/pkg/token"
+	"github.com/z7zmey/php-parser/pkg/version"
 )
 
 func TestIdentifier(t *testing.T) {
@@ -95,8 +97,14 @@ func TestIdentifier(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -1394,8 +1402,14 @@ func TestPhp5ArgumentNode(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -2986,8 +3000,14 @@ func TestPhp5ParameterNode(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3040,8 +3060,14 @@ func TestCommentEndFile(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3161,8 +3187,14 @@ func TestName(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3290,8 +3322,14 @@ func TestFullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3429,8 +3467,14 @@ func TestRelative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3569,8 +3613,14 @@ func TestScalarEncapsed_SimpleVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3707,8 +3757,14 @@ func TestScalarEncapsed_SimpleVarOneChar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3864,8 +3920,14 @@ func TestScalarEncapsed_SimpleVarEndsEcapsed(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4057,8 +4119,14 @@ func TestScalarEncapsed_StringVarCurveOpen(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4251,8 +4319,14 @@ func TestScalarEncapsed_SimpleVarPropertyFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4409,8 +4483,14 @@ func TestScalarEncapsed_DollarOpenCurlyBraces(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4606,8 +4686,14 @@ func TestScalarEncapsed_DollarOpenCurlyBracesDimNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4829,8 +4915,14 @@ func TestScalarEncapsed_CurlyOpenMethodCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5002,8 +5094,14 @@ LBL;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5175,8 +5273,14 @@ LBL;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5302,8 +5406,14 @@ LBL;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5407,8 +5517,14 @@ CAD;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5534,8 +5650,14 @@ CAD;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5616,8 +5738,14 @@ func TestScalarMagicConstant(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5697,8 +5825,14 @@ func TestScalarNumber_LNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5778,8 +5912,14 @@ func TestScalarNumber_DNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5859,8 +5999,14 @@ func TestScalarNumber_Float(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5940,8 +6086,14 @@ func TestScalarNumber_BinaryLNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6021,8 +6173,14 @@ func TestScalarNumber_BinaryDNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6102,8 +6260,14 @@ func TestScalarNumber_HLNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6183,8 +6347,14 @@ func TestScalarNumber_HDNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6264,8 +6434,14 @@ func TestScalarString_DoubleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6345,8 +6521,14 @@ func TestScalarString_DoubleQuotedScalarStringWithEscapedVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6428,8 +6610,14 @@ func TestScalarString_MultilineDoubleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6509,8 +6697,14 @@ func TestScalarString_SingleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6592,8 +6786,14 @@ func TestScalarString_MultilineSingleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6780,8 +6980,14 @@ func TestStmtAltIf_AltIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -7091,8 +7297,14 @@ func TestStmtAltIf_AltElseIf(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -7341,8 +7553,14 @@ func TestStmtAltIf_AltElse(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -7811,8 +8029,14 @@ func TestStmtAltIf_AltElseElseIf(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -8176,8 +8400,14 @@ func TestStmtClassConstList_WithoutModifiers(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -8425,8 +8655,14 @@ func TestStmtClassMethod_SimpleClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -8893,8 +9129,14 @@ func TestStmtClassMethod_PrivateProtectedClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -9216,8 +9458,14 @@ func TestStmtClassMethod_Php5ClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -9539,8 +9787,14 @@ func TestStmtClassMethod_AbstractClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -9665,8 +9919,14 @@ func TestStmtClass_SimpleClass(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -9824,8 +10084,14 @@ func TestStmtClass_AbstractClass(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10058,8 +10324,14 @@ func TestStmtClass_ClassExtends(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10294,8 +10566,14 @@ func TestStmtClass_ClassImplement(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10583,8 +10861,14 @@ func TestStmtClass_ClassImplements(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10853,8 +11137,14 @@ func TestStmtConstList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11060,8 +11350,14 @@ func TestStmtContinue_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11298,8 +11594,14 @@ func TestStmtContinue_Light(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11552,8 +11854,14 @@ func TestStmtContinue(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11710,8 +12018,14 @@ func TestStmtDeclare(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11971,8 +12285,14 @@ func TestStmtDeclare_Stmts(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12162,8 +12482,14 @@ func TestStmtDeclare_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12336,8 +12662,14 @@ func TestStmtDo(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12492,8 +12824,14 @@ func TestStmtEcho(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12621,8 +12959,14 @@ func TestStmtEcho_Parenthesis(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12758,8 +13102,14 @@ func TestStmtExpression(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13221,8 +13571,14 @@ func TestStmtFor(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13547,8 +13903,14 @@ func TestStmtFor_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13770,8 +14132,14 @@ func TestStmtForeach(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13994,8 +14362,14 @@ func TestStmtForeach_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14239,8 +14613,14 @@ func TestStmtForeach_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14523,8 +14903,14 @@ func TestStmtForeach_WithKey(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14808,8 +15194,14 @@ func TestStmtForeach_ExprWithKey(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15102,8 +15494,14 @@ func TestStmtForeach_WithRef(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15434,8 +15832,14 @@ func TestStmtForeach_WithList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15580,8 +15984,14 @@ func TestStmtFunction(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15755,8 +16165,14 @@ func TestStmtFunction_Return(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16127,8 +16543,14 @@ func TestStmtFunction_ReturnVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16343,8 +16765,14 @@ func TestStmtFunction_Ref(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16456,8 +16884,14 @@ func TestStmtGlobal(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16804,8 +17238,14 @@ func TestStmtGlobal_Vars(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16956,8 +17396,14 @@ func TestStmtGotoLabel(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17048,8 +17494,14 @@ func TestStmtHaltCompiler(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17210,8 +17662,14 @@ func TestStmtIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17504,8 +17962,14 @@ func TestStmtIf_ElseIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17737,8 +18201,14 @@ func TestStmtIf_Else(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18232,8 +18702,14 @@ func TestStmtIf_ElseElseIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18757,8 +19233,14 @@ func TestStmtIf_ElseIfElseIfElse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18838,8 +19320,14 @@ func TestStmtInlineHtml(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18964,8 +19452,14 @@ func TestStmtInterface(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19155,8 +19649,14 @@ func TestStmtInterface_Extend(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19399,8 +19899,14 @@ func TestStmtInterface_Extends(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19512,8 +20018,14 @@ func TestStmtNamespace(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19648,8 +20160,14 @@ func TestStmtNamespace_Stmts(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19743,8 +20261,14 @@ func TestStmtNamespace_Anonymous(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19958,8 +20482,14 @@ func TestStmtProperty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20316,8 +20846,14 @@ func TestStmtProperty_Properties(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20674,8 +21210,14 @@ func TestStmtProperty_Properties2(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20795,8 +21337,14 @@ func TestStmtStaticVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21028,8 +21576,14 @@ func TestStmtStaticVar_Vars(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21261,8 +21815,14 @@ func TestStmtStaticVar_Vars2(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21650,8 +22210,14 @@ func TestStmtSwitch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22049,8 +22615,14 @@ func TestStmtSwitch_Semicolon(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22408,8 +22980,14 @@ func TestStmtSwitch_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22735,8 +23313,14 @@ func TestStmtSwitch_AltSemicolon(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22846,8 +23430,14 @@ func TestStmtThrow(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22972,8 +23562,14 @@ func TestStmtTrait(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -23194,8 +23790,14 @@ func TestStmtTraitUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -23469,8 +24071,14 @@ func TestStmtTraitUse_Uses(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -23766,8 +24374,14 @@ func TestStmtTraitUse_EmptyAdaptations(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24179,8 +24793,14 @@ func TestStmtTraitUse_Modifier(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24623,8 +25243,14 @@ func TestStmtTraitUse_AliasModifier(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -25281,8 +25907,14 @@ func TestStmtTraitUse_Adaptions(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -25378,8 +26010,14 @@ func TestStmtTry_Try(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -25641,8 +26279,14 @@ func TestStmtTry_TryCatch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -26069,8 +26713,14 @@ func TestStmtTry_TryCatchCatch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -26395,8 +27045,14 @@ func TestStmtTry_TryCatchFinally(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27017,8 +27673,14 @@ func TestStmtTry_TryCatchCatchCatch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27138,8 +27800,14 @@ func TestStmtUnset(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27310,8 +27978,14 @@ func TestStmtUnset_Vars(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27433,8 +28107,14 @@ func TestStmtUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27566,8 +28246,14 @@ func TestStmtUse_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27752,8 +28438,14 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27936,8 +28628,14 @@ func TestStmtUse_List(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -28173,8 +28871,14 @@ func TestStmtUse_ListAlias(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -28398,8 +29102,14 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -28729,8 +29439,14 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -28954,8 +29670,14 @@ func TestStmtUse_ListConstType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29285,8 +30007,14 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29492,8 +30220,14 @@ func TestStmtBreak_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29730,8 +30464,14 @@ func TestStmtBreak_Light(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29994,8 +30734,14 @@ func TestStmtBreak(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30132,8 +30878,14 @@ func TestExprArrayDimFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30315,8 +31067,14 @@ func TestExprArrayDimFetch_Nested(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30415,8 +31173,14 @@ func TestExprArray(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30544,8 +31308,14 @@ func TestExprArray_Item(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30782,8 +31552,14 @@ func TestExprArray_Items(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30889,8 +31665,14 @@ func TestExprBitwiseNot(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30996,8 +31778,14 @@ func TestExprBooleanNot(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31124,8 +31912,14 @@ func TestExprClassConstFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31242,8 +32036,14 @@ func TestExprClassConstFetch_Static(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31377,8 +32177,14 @@ func TestExprClone_Brackets(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31496,8 +32302,14 @@ func TestExprClone(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31617,8 +32429,14 @@ func TestExprClosure(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32006,8 +32824,14 @@ func TestExprClosure_Use(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32395,8 +33219,14 @@ func TestExprClosure_Use2(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32494,8 +33324,14 @@ func TestExprConstFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32613,8 +33449,14 @@ func TestExprConstFetch_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32722,8 +33564,14 @@ func TestExprConstFetch_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32849,8 +33697,14 @@ func TestExprEmpty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32956,8 +33810,14 @@ func TestExprErrorSuppress(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33083,8 +33943,14 @@ func TestExprEval(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33163,8 +34029,14 @@ func TestExprExit(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33263,8 +34135,14 @@ func TestExprExit_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33390,8 +34268,14 @@ func TestExprExit_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33470,8 +34354,14 @@ func TestExprDie(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33570,8 +34460,14 @@ func TestExprDie_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33697,8 +34593,14 @@ func TestExprDie_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33816,8 +34718,14 @@ func TestExprFunctionCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33955,8 +34863,14 @@ func TestExprFunctionCall_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34122,8 +35036,14 @@ func TestExprFunctionCall_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34306,8 +35226,14 @@ func TestExprFunctionCall_Var(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34499,8 +35425,14 @@ func TestExprFunctionCall_ExprArg(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34606,8 +35538,14 @@ func TestExprPostDec(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34713,8 +35651,14 @@ func TestExprPostInc(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34820,8 +35764,14 @@ func TestExprPreDec(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34927,8 +35877,14 @@ func TestExprPreInc(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35046,8 +36002,14 @@ func TestExprInclude(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35165,8 +36127,14 @@ func TestExprInclude_Once(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35284,8 +36252,14 @@ func TestExprRequire(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35403,8 +36377,14 @@ func TestExprRequire_Once(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35563,8 +36543,14 @@ func TestExprInstanceOf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35743,8 +36729,14 @@ func TestExprInstanceOf_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35913,8 +36905,14 @@ func TestExprInstanceOf_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36042,8 +37040,14 @@ func TestExprIsset(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36222,8 +37226,14 @@ func TestExprIsset_Variables(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36394,8 +37404,14 @@ func TestExprList_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36600,8 +37616,14 @@ func TestExprList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36834,8 +37856,14 @@ func TestExprList_ArrayIndex(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37088,8 +38116,14 @@ func TestExprList_List(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37319,8 +38353,14 @@ func TestExprList_EmptyItem(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37596,8 +38636,14 @@ func TestExprList_EmptyItems(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37742,8 +38788,14 @@ func TestExprMethodCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37863,8 +38915,14 @@ func TestExprNew(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38024,8 +39082,14 @@ func TestExprNew_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38175,8 +39239,14 @@ func TestExprNew_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38310,8 +39380,14 @@ func TestExprPrint(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38438,8 +39514,14 @@ func TestExprPropertyFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38576,8 +39658,14 @@ func TestExprShellExec(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38666,8 +39754,14 @@ func TestExprShortArray(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38785,8 +39879,14 @@ func TestExprShortArray_Item(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39013,8 +40113,14 @@ func TestExprShortArray_Items(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39161,8 +40267,14 @@ func TestExprStaticCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39329,8 +40441,14 @@ func TestExprStaticCall_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39487,8 +40605,14 @@ func TestExprStaticCall_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39643,8 +40767,14 @@ func TestExprStaticCall_Var(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39797,8 +40927,14 @@ func TestExprStaticCall_VarVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39933,8 +41069,14 @@ func TestExprStaticPropertyFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40089,8 +41231,14 @@ func TestExprStaticPropertyFetch_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40235,8 +41383,14 @@ func TestExprStaticPropertyFetch_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40454,8 +41608,14 @@ func TestExprTernary(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40634,8 +41794,14 @@ func TestExprTernary_Simple(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40983,8 +42149,14 @@ func TestExprTernary_NestedTrue(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41332,8 +42504,14 @@ func TestExprTernary_NestedCond(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41439,8 +42617,14 @@ func TestExprUnaryMinus(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41546,8 +42730,14 @@ func TestExprUnaryPlus(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41635,8 +42825,14 @@ func TestExprVariable(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41742,8 +42938,14 @@ func TestExprVariable_Variable(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41822,8 +43024,14 @@ func TestExprYield(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41941,8 +43149,14 @@ func TestExprYield_Val(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42121,8 +43335,14 @@ func TestExprYield_KeyVal(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42232,8 +43452,14 @@ func TestExprYield_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42404,8 +43630,14 @@ func TestExprYield_KeyExpr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -44621,8 +45853,14 @@ func TestExprAssign(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47830,8 +49068,14 @@ func TestExprBinary_BitwiseAnd(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -48700,8 +49944,14 @@ func TestExprCast_Array(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -49000,8 +50250,14 @@ func TestPhp5Strings(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -49480,8 +50736,14 @@ CAD;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	actual := php5parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -49502,12 +50764,18 @@ func TestPhp5ControlCharsErrors(t *testing.T) {
 	}
 
 	parserErrors := []*errors.Error{}
-	errorHandlerFunc := func(e *errors.Error) {
-		parserErrors = append(parserErrors, e)
-	}
 
-	lexer := scanner.NewLexer([]byte(src), "5.6", errorHandlerFunc)
-	php5parser := php5.NewParser(lexer, errorHandlerFunc)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+		ErrorHandlerFunc: func(e *errors.Error) {
+			parserErrors = append(parserErrors, e)
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 	assert.DeepEqual(t, expected, parserErrors)
 }
diff --git a/internal/php5/php5_bench_test.go b/internal/php5/php5_bench_test.go
index 77c67cc..b17c36f 100644
--- a/internal/php5/php5_bench_test.go
+++ b/internal/php5/php5_bench_test.go
@@ -6,6 +6,8 @@ import (
 
 	"github.com/z7zmey/php-parser/internal/php5"
 	"github.com/z7zmey/php-parser/internal/scanner"
+	"github.com/z7zmey/php-parser/pkg/cfg"
+	"github.com/z7zmey/php-parser/pkg/version"
 )
 
 func BenchmarkPhp5(b *testing.B) {
@@ -15,8 +17,14 @@ func BenchmarkPhp5(b *testing.B) {
 	}
 
 	for n := 0; n < b.N; n++ {
-		lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-		php5parser := php5.NewParser(lexer, nil)
+		config := cfg.Config{
+			Version: &version.Version{
+				Major: 5,
+				Minor: 6,
+			},
+		}
+		lexer := scanner.NewLexer(src, config)
+		php5parser := php5.NewParser(lexer, config)
 		php5parser.Parse()
 	}
 }
diff --git a/internal/php7/parser.go b/internal/php7/parser.go
index f053888..eda2135 100644
--- a/internal/php7/parser.go
+++ b/internal/php7/parser.go
@@ -1,9 +1,10 @@
 package php7
 
 import (
-	builder "github.com/z7zmey/php-parser/internal/position"
+	"github.com/z7zmey/php-parser/internal/position"
 	"github.com/z7zmey/php-parser/internal/scanner"
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
 	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/token"
 )
@@ -14,15 +15,15 @@ type Parser struct {
 	currentToken   *token.Token
 	rootNode       ast.Vertex
 	errHandlerFunc func(*errors.Error)
-	builder        *builder.Builder
+	builder        *position.Builder
 }
 
 // NewParser creates and returns new Parser
-func NewParser(lexer *scanner.Lexer, errHandlerFunc func(*errors.Error)) *Parser {
+func NewParser(lexer *scanner.Lexer, config cfg.Config) *Parser {
 	return &Parser{
 		Lexer:          lexer,
-		errHandlerFunc: errHandlerFunc,
-		builder:        builder.NewBuilder(),
+		errHandlerFunc: config.ErrorHandlerFunc,
+		builder:        position.NewBuilder(),
 	}
 }
 
diff --git a/internal/php7/parser_test.go b/internal/php7/parser_test.go
index b35eece..3df90af 100644
--- a/internal/php7/parser_test.go
+++ b/internal/php7/parser_test.go
@@ -1,7 +1,6 @@
 package php7_test
 
 import (
-	"github.com/z7zmey/php-parser/pkg/errors"
 	"testing"
 
 	"gotest.tools/assert"
@@ -9,8 +8,11 @@ import (
 	"github.com/z7zmey/php-parser/internal/php7"
 	"github.com/z7zmey/php-parser/internal/scanner"
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
+	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/position"
 	"github.com/z7zmey/php-parser/pkg/token"
+	"github.com/z7zmey/php-parser/pkg/version"
 )
 
 func TestIdentifier(t *testing.T) {
@@ -95,8 +97,14 @@ func TestIdentifier(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -1665,8 +1673,14 @@ func TestPhp7ArgumentNode(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3343,8 +3357,14 @@ func TestPhp7ParameterNode(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3397,8 +3417,14 @@ func TestCommentEndFile(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3518,8 +3544,14 @@ func TestName(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3647,8 +3679,14 @@ func TestFullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3786,8 +3824,14 @@ func TestRelative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -3926,8 +3970,14 @@ func TestScalarEncapsed_SimpleVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4064,8 +4114,14 @@ func TestScalarEncapsed_SimpleVarOneChar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4221,8 +4277,14 @@ func TestScalarEncapsed_SimpleVarEndsEcapsed(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4414,8 +4476,14 @@ func TestScalarEncapsed_StringVarCurveOpen(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4608,8 +4676,14 @@ func TestScalarEncapsed_SimpleVarPropertyFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4766,8 +4840,14 @@ func TestScalarEncapsed_DollarOpenCurlyBraces(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -4963,8 +5043,14 @@ func TestScalarEncapsed_DollarOpenCurlyBracesDimNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5186,8 +5272,14 @@ func TestScalarEncapsed_CurlyOpenMethodCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5359,8 +5451,14 @@ LBL;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5532,8 +5630,14 @@ LBL;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5659,8 +5763,14 @@ LBL;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5764,8 +5874,14 @@ CAD;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5891,8 +6007,14 @@ CAD;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -5973,8 +6095,14 @@ func TestScalarMagicConstant(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6054,8 +6182,14 @@ func TestScalarNumber_LNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6135,8 +6269,14 @@ func TestScalarNumber_DNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6216,8 +6356,14 @@ func TestScalarNumber_Float(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6297,8 +6443,14 @@ func TestScalarNumber_BinaryLNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6378,8 +6530,14 @@ func TestScalarNumber_BinaryDNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6459,8 +6617,14 @@ func TestScalarNumber_HLNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6540,8 +6704,14 @@ func TestScalarNumber_HDNumber(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6621,8 +6791,14 @@ func TestScalarString_DoubleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6702,8 +6878,14 @@ func TestScalarString_DoubleQuotedScalarStringWithEscapedVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6785,8 +6967,14 @@ func TestScalarString_MultilineDoubleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6866,8 +7054,14 @@ func TestScalarString_SingleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -6949,8 +7143,14 @@ func TestScalarString_MultilineSingleQuotedScalarString(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -7151,8 +7351,14 @@ func TestStmtAltIf_AltIf(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -7462,8 +7668,14 @@ func TestStmtAltIf_AltElseIf(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -7712,8 +7924,14 @@ func TestStmtAltIf_AltElse(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -8182,8 +8400,14 @@ func TestStmtAltIf_AltElseElseIf(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -8580,8 +8804,14 @@ func TestStmtClassConstList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -8945,8 +9175,14 @@ func TestStmtClassConstList_WithoutModifiers(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -9194,8 +9430,14 @@ func TestStmtClassMethod_SimpleClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -9662,8 +9904,14 @@ func TestStmtClassMethod_PrivateProtectedClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10036,8 +10284,14 @@ func TestStmtClassMethod_Php7ClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10359,8 +10613,14 @@ func TestStmtClassMethod_AbstractClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10702,8 +10962,14 @@ func TestStmtClassMethod_Php7AbstractClassMethod(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10828,8 +11094,14 @@ func TestStmtClass_SimpleClass(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -10987,8 +11259,14 @@ func TestStmtClass_AbstractClass(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11221,8 +11499,14 @@ func TestStmtClass_ClassExtends(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11457,8 +11741,14 @@ func TestStmtClass_ClassImplement(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -11746,8 +12036,14 @@ func TestStmtClass_ClassImplements(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12102,8 +12398,14 @@ func TestStmtClass_AnonimousClass(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12372,8 +12674,14 @@ func TestStmtConstList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12579,8 +12887,14 @@ func TestStmtContinue_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -12817,8 +13131,14 @@ func TestStmtContinue_Light(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13071,8 +13391,14 @@ func TestStmtContinue(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13229,8 +13555,14 @@ func TestStmtDeclare(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13490,8 +13822,14 @@ func TestStmtDeclare_Stmts(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13681,8 +14019,14 @@ func TestStmtDeclare_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -13855,8 +14199,14 @@ func TestStmtDo(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14011,8 +14361,14 @@ func TestStmtEcho(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14140,8 +14496,14 @@ func TestStmtEcho_Parenthesis(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14221,8 +14583,14 @@ func TestStmtExpression(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -14684,8 +15052,14 @@ func TestStmtFor(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15010,8 +15384,14 @@ func TestStmtFor_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15233,8 +15613,14 @@ func TestStmtForeach(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15457,8 +15843,14 @@ func TestStmtForeach_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15702,8 +16094,14 @@ func TestStmtForeach_Alt(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -15986,8 +16384,14 @@ func TestStmtForeach_WithKey(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16271,8 +16675,14 @@ func TestStmtForeach_ExprWithKey(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16565,8 +16975,14 @@ func TestStmtForeach_WithRef(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -16897,8 +17313,14 @@ func TestStmtForeach_WithList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17043,8 +17465,14 @@ func TestStmtFunction(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17218,8 +17646,14 @@ func TestStmtFunction_Return(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17590,8 +18024,14 @@ func TestStmtFunction_ReturnVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -17806,8 +18246,14 @@ func TestStmtFunction_Ref(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18013,8 +18459,14 @@ func TestStmtFunction_ReturnType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18126,8 +18578,14 @@ func TestStmtGlobal(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18474,8 +18932,14 @@ func TestStmtGlobal_Vars(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18626,8 +19090,14 @@ func TestStmtGotoLabel(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18718,8 +19188,14 @@ func TestStmtHaltCompiler(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -18880,8 +19356,14 @@ func TestStmtIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19174,8 +19656,14 @@ func TestStmtIf_ElseIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19407,8 +19895,14 @@ func TestStmtIf_Else(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -19902,8 +20396,14 @@ func TestStmtIf_ElseElseIf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20427,8 +20927,14 @@ func TestStmtIf_ElseIfElseIfElse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20508,8 +21014,14 @@ func TestStmtInlineHtml(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20634,8 +21146,14 @@ func TestStmtInterface(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -20825,8 +21343,14 @@ func TestStmtInterface_Extend(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21069,8 +21593,14 @@ func TestStmtInterface_Extends(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21182,8 +21712,14 @@ func TestStmtNamespace(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21318,8 +21854,14 @@ func TestStmtNamespace_Stmts(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21413,8 +21955,14 @@ func TestStmtNamespace_Anonymous(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21628,8 +22176,14 @@ func TestStmtProperty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -21986,8 +22540,14 @@ func TestStmtProperty_Properties(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22344,8 +22904,14 @@ func TestStmtProperty_Properties2(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22600,8 +23166,14 @@ func TestStmtProperty_PropertyType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22721,8 +23293,14 @@ func TestStmtStaticVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -22954,8 +23532,14 @@ func TestStmtStaticVar_Vars(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -23187,8 +23771,14 @@ func TestStmtStaticVar_Vars2(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -23590,8 +24180,14 @@ func TestStmtSwitch(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24003,8 +24599,14 @@ func TestStmtSwitch_Semicolon(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24376,8 +24978,14 @@ func TestStmtSwitch_Alt(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24703,8 +25311,14 @@ func TestStmtSwitch_AltSemicolon(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24814,8 +25428,14 @@ func TestStmtThrow(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -24940,8 +25560,14 @@ func TestStmtTrait(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -25162,8 +25788,14 @@ func TestStmtTraitUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -25437,8 +26069,14 @@ func TestStmtTraitUse_Uses(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -25734,8 +26372,14 @@ func TestStmtTraitUse_EmptyAdaptations(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -26147,8 +26791,14 @@ func TestStmtTraitUse_Modifier(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -26591,8 +27241,14 @@ func TestStmtTraitUse_AliasModifier(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27249,8 +27905,14 @@ func TestStmtTraitUse_Adaptions(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27360,8 +28022,14 @@ func TestStmtTry_Try(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27637,8 +28305,14 @@ func TestStmtTry_TryCatch(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -27955,8 +28629,14 @@ func TestStmtTry_Php7TryCatch(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -28397,8 +29077,14 @@ func TestStmtTry_TryCatchCatch(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -28737,8 +29423,14 @@ func TestStmtTry_TryCatchFinally(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29359,8 +30051,14 @@ func TestStmtTry_TryCatchCatchCatch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29480,8 +30178,14 @@ func TestStmtUnset(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29652,8 +30356,14 @@ func TestStmtUnset_Vars(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29834,8 +30544,14 @@ func TestStmtUnset_TrailingComma(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -29957,8 +30673,14 @@ func TestStmtUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30090,8 +30812,14 @@ func TestStmtUse_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30276,8 +31004,14 @@ func TestStmtUse_FullyQualifiedAlias(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30460,8 +31194,14 @@ func TestStmtUse_List(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30697,8 +31437,14 @@ func TestStmtUse_ListAlias(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -30922,8 +31668,14 @@ func TestStmtUse_ListFunctionType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31253,8 +32005,14 @@ func TestStmtUse_ListFunctionTypeAliases(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31478,8 +32236,14 @@ func TestStmtUse_ListConstType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -31809,8 +32573,14 @@ func TestStmtUse_ListConstTypeAliases(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32052,8 +32822,14 @@ func TestStmtUse_GroupUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32348,8 +33124,14 @@ func TestStmtUse_GroupUseAlias(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32622,8 +33404,14 @@ func TestStmtUse_FunctionGroupUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -32896,8 +33684,14 @@ func TestStmtUse_ConstGroupUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33201,8 +33995,14 @@ func TestStmtUse_MixedGroupUse(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33408,8 +34208,14 @@ func TestStmtBreak_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33646,8 +34452,14 @@ func TestStmtBreak_Light(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -33910,8 +34722,14 @@ func TestStmtBreak(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34048,8 +34866,14 @@ func TestExprArrayDimFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34231,8 +35055,14 @@ func TestExprArrayDimFetch_Nested(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34331,8 +35161,14 @@ func TestExprArray(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34460,8 +35296,14 @@ func TestExprArray_Item(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34698,8 +35540,14 @@ func TestExprArray_Items(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -34845,8 +35693,14 @@ func TestExprArray_ItemUnpack(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35006,8 +35860,14 @@ func TestExprArrowFunction(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35264,8 +36124,14 @@ func TestExprArrowFunction_ReturnType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35371,8 +36237,14 @@ func TestExprBitwiseNot(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35478,8 +36350,14 @@ func TestExprBooleanNot(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35606,8 +36484,14 @@ func TestExprClassConstFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35724,8 +36608,14 @@ func TestExprClassConstFetch_Static(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35859,8 +36749,14 @@ func TestExprClone_Brackets(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -35978,8 +36874,14 @@ func TestExprClone(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36099,8 +37001,14 @@ func TestExprClosure(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36488,8 +37396,14 @@ func TestExprClosure_Use(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -36877,8 +37791,14 @@ func TestExprClosure_Use2(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37061,8 +37981,14 @@ func TestExprClosure_ReturnType(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37160,8 +38086,14 @@ func TestExprConstFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37279,8 +38211,14 @@ func TestExprConstFetch_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37388,8 +38326,14 @@ func TestExprConstFetch_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37515,8 +38459,14 @@ func TestExprEmpty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37622,8 +38572,14 @@ func TestExprErrorSuppress(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37749,8 +38705,14 @@ func TestExprEval(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37829,8 +38791,14 @@ func TestExprExit(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -37929,8 +38897,14 @@ func TestExprExit_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38056,8 +39030,14 @@ func TestExprExit_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38136,8 +39116,14 @@ func TestExprDie(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38236,8 +39222,14 @@ func TestExprDie_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38363,8 +39355,14 @@ func TestExprDie_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38482,8 +39480,14 @@ func TestExprFunctionCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38621,8 +39625,14 @@ func TestExprFunctionCall_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38788,8 +39798,14 @@ func TestExprFunctionCall_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -38972,8 +39988,14 @@ func TestExprFunctionCall_Var(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39165,8 +40187,14 @@ func TestExprFunctionCall_ExprArg(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39272,8 +40300,14 @@ func TestExprPostDec(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39379,8 +40413,14 @@ func TestExprPostInc(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39486,8 +40526,14 @@ func TestExprPreDec(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39593,8 +40639,14 @@ func TestExprPreInc(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39712,8 +40764,14 @@ func TestExprInclude(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39831,8 +40889,14 @@ func TestExprInclude_Once(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -39950,8 +41014,14 @@ func TestExprRequire(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40069,8 +41139,14 @@ func TestExprRequire_Once(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40229,8 +41305,14 @@ func TestExprInstanceOf(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40409,8 +41491,14 @@ func TestExprInstanceOf_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40579,8 +41667,14 @@ func TestExprInstanceOf_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40708,8 +41802,14 @@ func TestExprIsset(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -40888,8 +41988,14 @@ func TestExprIsset_Variables(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41057,8 +42163,14 @@ func TestExprList_Empty(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41263,8 +42375,14 @@ func TestExprList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41497,8 +42615,14 @@ func TestExprList_ArrayIndex(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41751,8 +42875,14 @@ func TestExprList_List(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -41982,8 +43112,14 @@ func TestExprList_EmptyItem(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42259,8 +43395,14 @@ func TestExprList_EmptyItems(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42405,8 +43547,14 @@ func TestExprMethodCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42526,8 +43674,14 @@ func TestExprNew(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42687,8 +43841,14 @@ func TestExprNew_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -42838,8 +43998,14 @@ func TestExprNew_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43119,8 +44285,14 @@ func TestExprNew_Anonymous(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43254,8 +44426,14 @@ func TestExprPrint(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43380,8 +44558,14 @@ func TestExprPropertyFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43518,8 +44702,14 @@ func TestExprShellExec(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43608,8 +44798,14 @@ func TestExprShortArray(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43727,8 +44923,14 @@ func TestExprShortArray_Item(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -43955,8 +45157,14 @@ func TestExprShortArray_Items(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -44151,8 +45359,14 @@ func TestExprShortList(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -44375,8 +45589,14 @@ func TestExprShortList_ArrayIndex(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -44619,8 +45839,14 @@ func TestExprShortList_List(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -44767,8 +45993,14 @@ func TestExprStaticCall(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -44935,8 +46167,14 @@ func TestExprStaticCall_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -45093,8 +46331,14 @@ func TestExprStaticCall_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -45249,8 +46493,14 @@ func TestExprStaticCall_Var(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -45403,8 +46653,14 @@ func TestExprStaticCall_VarVar(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -45539,8 +46795,14 @@ func TestExprStaticPropertyFetch(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -45695,8 +46957,14 @@ func TestExprStaticPropertyFetch_Relative(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -45841,8 +47109,14 @@ func TestExprStaticPropertyFetch_FullyQualified(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -46060,8 +47334,14 @@ func TestExprTernary(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -46240,8 +47520,14 @@ func TestExprTernary_Simple(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -46589,8 +47875,14 @@ func TestExprTernary_NestedTrue(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -46938,8 +48230,14 @@ func TestExprTernary_NestedCond(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47045,8 +48343,14 @@ func TestExprUnaryMinus(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47152,8 +48456,14 @@ func TestExprUnaryPlus(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47241,8 +48551,14 @@ func TestExprVariable(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47348,8 +48664,14 @@ func TestExprVariable_Variable(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47428,8 +48750,14 @@ func TestExprYield(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47547,8 +48875,14 @@ func TestExprYield_Val(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47727,8 +49061,14 @@ func TestExprYield_KeyVal(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -47838,8 +49178,14 @@ func TestExprYield_Expr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -48010,8 +49356,14 @@ func TestExprYield_KeyExpr(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -48129,8 +49481,14 @@ func TestExprYieldFrom(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -50473,8 +51831,14 @@ func TestExprAssign_Assign(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -53936,8 +55300,14 @@ func TestExprBinary_BitwiseAnd(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -54806,8 +56176,14 @@ func TestExprCast_Array(t *testing.T) {
 		EndTkn: &token.Token{},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -55106,8 +56482,14 @@ func TestStrings(t *testing.T) {
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -55586,8 +56968,14 @@ CAD;
 		},
 	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	actual := php7parser.GetRootNode()
 	assert.DeepEqual(t, expected, actual)
@@ -55608,12 +56996,18 @@ func TestControlCharsErrors(t *testing.T) {
 	}
 
 	parserErrors := []*errors.Error{}
-	errorHandlerFunc := func(e *errors.Error) {
-		parserErrors = append(parserErrors, e)
-	}
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", errorHandlerFunc)
-	php7parser := php7.NewParser(lexer, errorHandlerFunc)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+		ErrorHandlerFunc: func(e *errors.Error) {
+			parserErrors = append(parserErrors, e)
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 	assert.DeepEqual(t, expected, parserErrors)
 }
diff --git a/internal/php7/php7_bench_test.go b/internal/php7/php7_bench_test.go
index 3ba6578..961688d 100644
--- a/internal/php7/php7_bench_test.go
+++ b/internal/php7/php7_bench_test.go
@@ -6,6 +6,8 @@ import (
 
 	"github.com/z7zmey/php-parser/internal/php7"
 	"github.com/z7zmey/php-parser/internal/scanner"
+	"github.com/z7zmey/php-parser/pkg/cfg"
+	"github.com/z7zmey/php-parser/pkg/version"
 )
 
 func BenchmarkPhp7(b *testing.B) {
@@ -16,8 +18,14 @@ func BenchmarkPhp7(b *testing.B) {
 	}
 
 	for n := 0; n < b.N; n++ {
-		lexer := scanner.NewLexer(src, "7.4", nil)
-		php7parser := php7.NewParser(lexer, nil)
+		config := cfg.Config{
+			Version: &version.Version{
+				Major: 7,
+				Minor: 4,
+			},
+		}
+		lexer := scanner.NewLexer(src, config)
+		php7parser := php7.NewParser(lexer, config)
 		php7parser.Parse()
 	}
 }
diff --git a/internal/scanner/lexer.go b/internal/scanner/lexer.go
index 6a26ffc..eea6e16 100644
--- a/internal/scanner/lexer.go
+++ b/internal/scanner/lexer.go
@@ -4,15 +4,16 @@ import (
 	"bytes"
 	"strings"
 
-	"github.com/z7zmey/php-parser/internal/version"
+	"github.com/z7zmey/php-parser/pkg/cfg"
 	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/position"
 	"github.com/z7zmey/php-parser/pkg/token"
+	"github.com/z7zmey/php-parser/pkg/version"
 )
 
 type Lexer struct {
 	data           []byte
-	phpVersion     string
+	phpVersion     *version.Version
 	errHandlerFunc func(*errors.Error)
 
 	p, pe, cs   int
@@ -26,11 +27,11 @@ type Lexer struct {
 	newLines     NewLines
 }
 
-func NewLexer(data []byte, phpVersion string, errHandlerFunc func(*errors.Error)) *Lexer {
+func NewLexer(data []byte, config cfg.Config) *Lexer {
 	lex := &Lexer{
 		data:           data,
-		phpVersion:     phpVersion,
-		errHandlerFunc: errHandlerFunc,
+		phpVersion:     config.Version,
+		errHandlerFunc: config.ErrorHandlerFunc,
 
 		pe:    len(data),
 		stack: make([]int, 0),
@@ -101,16 +102,16 @@ func (lex *Lexer) isNotStringEnd(s byte) bool {
 }
 
 func (lex *Lexer) isHeredocEnd(p int) bool {
-	r, err := version.Compare(lex.phpVersion, "7.3")
+	o, err := version.New("7.3")
 	if err != nil {
+		panic(err)
+	}
+
+	if lex.phpVersion.GreaterOrEqual(o) {
 		return lex.isHeredocEndSince73(p)
 	}
 
-	if r == -1 {
-		return lex.isHeredocEndBefore73(p)
-	}
-
-	return lex.isHeredocEndSince73(p)
+	return lex.isHeredocEndBefore73(p)
 }
 
 func (lex *Lexer) isHeredocEndBefore73(p int) bool {
diff --git a/internal/scanner/scanner_test.go b/internal/scanner/scanner_test.go
index a51e6ea..af6da1f 100644
--- a/internal/scanner/scanner_test.go
+++ b/internal/scanner/scanner_test.go
@@ -4,9 +4,11 @@ import (
 	"gotest.tools/assert"
 	"testing"
 
+	"github.com/z7zmey/php-parser/pkg/cfg"
 	"github.com/z7zmey/php-parser/pkg/errors"
 	"github.com/z7zmey/php-parser/pkg/position"
 	"github.com/z7zmey/php-parser/pkg/token"
+	"github.com/z7zmey/php-parser/pkg/version"
 )
 
 func TestTokens(t *testing.T) {
@@ -353,7 +355,13 @@ func TestTokens(t *testing.T) {
 		token.T_UNSET_CAST.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -380,7 +388,13 @@ func TestShebang(t *testing.T) {
 		"\n",
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	tkn := lexer.Lex()
@@ -399,7 +413,13 @@ func TestShebangHtml(t *testing.T) {
 0.1
 `
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 	assert.Equal(t, tkn.ID, token.T_INLINE_HTML)
@@ -448,7 +468,13 @@ func TestNumberTokens(t *testing.T) {
 		token.T_DNUMBER.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -504,7 +530,13 @@ func TestConstantStrings(t *testing.T) {
 		token.T_CONSTANT_ENCAPSED_STRING.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -550,7 +582,13 @@ func TestSingleQuoteStringTokens(t *testing.T) {
 		token.T_CONSTANT_ENCAPSED_STRING.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -644,7 +682,13 @@ func TestTeplateStringTokens(t *testing.T) {
 		token.ID(int('"')).String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -734,7 +778,13 @@ func TestBackquoteStringTokens(t *testing.T) {
 		token.ID(int('`')).String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -827,7 +877,13 @@ CAT;
 		token.ID(int(';')).String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -899,7 +955,13 @@ CAT
 		token.T_END_HEREDOC.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -937,7 +999,13 @@ CAT;
 		token.ID(int(';')).String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -967,7 +1035,13 @@ func TestHereDocTokens73(t *testing.T) {
 		token.T_VARIABLE.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -996,8 +1070,13 @@ CAT;`
 		token.ID(int(';')).String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
-	lexer.phpVersion = "7.2"
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 2,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -1028,7 +1107,13 @@ func TestInlineHtmlNopTokens(t *testing.T) {
 		token.T_INLINE_HTML.String(),
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 
 	for {
@@ -1062,7 +1147,13 @@ func TestStringTokensAfterVariable(t *testing.T) {
 		"\"",
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 	actualTokens := []string{}
 
@@ -1095,7 +1186,13 @@ func TestSlashAfterVariable(t *testing.T) {
 		"3",
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 	actual := []string{}
 	actualTokens := []string{}
 
@@ -1132,7 +1229,13 @@ func TestCommentEnd(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1163,7 +1266,13 @@ func TestCommentNewLine(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1194,7 +1303,13 @@ func TestCommentNewLine1(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1225,7 +1340,13 @@ func TestCommentNewLine2(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1257,7 +1378,13 @@ func TestCommentWithPhpEndTag(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1289,7 +1416,13 @@ func TestInlineComment(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1321,7 +1454,13 @@ func TestInlineComment2(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1357,7 +1496,13 @@ func TestEmptyInlineComment(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1389,7 +1534,13 @@ func TestEmptyInlineComment2(t *testing.T) {
 		},
 	}
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 
@@ -1405,7 +1556,13 @@ func TestMethodCallTokens(t *testing.T) {
 	src := `<?php
 	$a -> bar ( '' ) ;`
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	expected := []*token.Token{
 		{
@@ -1507,7 +1664,13 @@ func TestYieldFromTokens(t *testing.T) {
 	src := `<?php
 	yield from $a`
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	expected := []*token.Token{
 		{
@@ -1543,7 +1706,13 @@ func TestYieldFromTokens(t *testing.T) {
 func TestVarNameByteChars(t *testing.T) {
 	src := "<?php $\x80 $\xff"
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 	assert.Equal(t, "$\x80", string(tkn.Value))
@@ -1555,7 +1724,13 @@ func TestVarNameByteChars(t *testing.T) {
 func TestStringVarNameByteChars(t *testing.T) {
 	src := "<?php \"$\x80 $\xff\""
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	tkn := lexer.Lex()
 	assert.Equal(t, "\"", string(tkn.Value))
@@ -1577,9 +1752,16 @@ func TestIgnoreControllCharacters(t *testing.T) {
 	src := "<?php \004 echo $b;"
 
 	var actualErr *errors.Error
-	lexer := NewLexer([]byte(src), "7.4", func(e *errors.Error) {
-		actualErr = e
-	})
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+		ErrorHandlerFunc: func(e *errors.Error) {
+			actualErr = e
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	expected := "echo"
 	tkn := lexer.Lex()
@@ -1601,7 +1783,13 @@ func TestIgnoreControllCharacters(t *testing.T) {
 func TestIgnoreControllCharactersAtStringVarOffset(t *testing.T) {
 	src := "<?php \"$a[test\004]\";"
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	expected := "\""
 	tkn := lexer.Lex()
@@ -1632,7 +1820,13 @@ func TestIgnoreControllCharactersAtStringVarOffset(t *testing.T) {
 func TestDoubleDollar(t *testing.T) {
 	src := `<?php "$$a";`
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	expected := "\""
 	tkn := lexer.Lex()
@@ -1653,7 +1847,13 @@ func TestDoubleDollar(t *testing.T) {
 func TestTripleDollar(t *testing.T) {
 	src := `<?php "$$$a";`
 
-	lexer := NewLexer([]byte(src), "7.4", nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := NewLexer([]byte(src), config)
 
 	expected := "\""
 	tkn := lexer.Lex()
diff --git a/internal/version/version.go b/internal/version/version.go
deleted file mode 100644
index 9834ebf..0000000
--- a/internal/version/version.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package version
-
-import (
-	"errors"
-	"strconv"
-	"strings"
-)
-
-type version struct {
-	major int
-	minor int
-}
-
-func Compare(a string, b string) (int, error) {
-	first, err := parse(a)
-	if err != nil {
-		return 0, err
-	}
-
-	second, err := parse(b)
-	if err != nil {
-		return 0, err
-	}
-
-	if first.major < second.major {
-		return -1, nil
-	}
-
-	if first.major > second.major {
-		return 1, nil
-	}
-
-	if first.minor < second.minor {
-		return -1, nil
-	}
-
-	if first.minor > second.minor {
-		return 1, nil
-	}
-
-	return 0, nil
-}
-
-func parse(v string) (version, error) {
-	i := strings.Index(v, ".")
-	if i == -1 {
-		return version{}, errors.New("version must contain major and minor parts")
-	}
-
-	major, err := strconv.Atoi(v[:i])
-	if err != nil {
-		return version{}, err
-	}
-
-	minor, err := strconv.Atoi(v[i+1:])
-	if err != nil {
-		return version{}, err
-	}
-
-	return version{major, minor}, nil
-}
diff --git a/internal/version/version_test.go b/internal/version/version_test.go
deleted file mode 100644
index 5f8a2f7..0000000
--- a/internal/version/version_test.go
+++ /dev/null
@@ -1,29 +0,0 @@
-package version_test
-
-import (
-	"gotest.tools/assert"
-	"testing"
-
-	"github.com/z7zmey/php-parser/internal/version"
-)
-
-func TestSmaller(t *testing.T) {
-	r, err := version.Compare("7.3", "5.6")
-
-	assert.NilError(t, err)
-	assert.Equal(t, 1, r)
-}
-
-func TestGreater(t *testing.T) {
-	r, err := version.Compare("5.6", "7.3")
-
-	assert.NilError(t, err)
-	assert.Equal(t, -1, r)
-}
-
-func TestEqual(t *testing.T) {
-	r, err := version.Compare("7.3", "7.3")
-
-	assert.NilError(t, err)
-	assert.Equal(t, 0, r)
-}
diff --git a/pkg/cfg/cfg.go b/pkg/cfg/cfg.go
new file mode 100644
index 0000000..1134e04
--- /dev/null
+++ b/pkg/cfg/cfg.go
@@ -0,0 +1,11 @@
+package cfg
+
+import (
+	"github.com/z7zmey/php-parser/pkg/errors"
+	"github.com/z7zmey/php-parser/pkg/version"
+)
+
+type Config struct {
+	Version          *version.Version
+	ErrorHandlerFunc func(e *errors.Error)
+}
diff --git a/pkg/parser/parser.go b/pkg/parser/parser.go
index a50d09e..343c60d 100644
--- a/pkg/parser/parser.go
+++ b/pkg/parser/parser.go
@@ -1,12 +1,25 @@
 package parser
 
 import (
+	"errors"
+
 	"github.com/z7zmey/php-parser/internal/php5"
 	"github.com/z7zmey/php-parser/internal/php7"
 	"github.com/z7zmey/php-parser/internal/scanner"
-	"github.com/z7zmey/php-parser/internal/version"
 	"github.com/z7zmey/php-parser/pkg/ast"
-	"github.com/z7zmey/php-parser/pkg/errors"
+	"github.com/z7zmey/php-parser/pkg/cfg"
+	"github.com/z7zmey/php-parser/pkg/version"
+)
+
+var (
+	// ErrVersionOutOfRange is returned if the version is not supported
+	ErrVersionOutOfRange = errors.New("the version is out of supported range")
+
+	php5RangeStart = &version.Version{Major: 5}
+	php5RangeEnd   = &version.Version{Major: 5, Minor: 6}
+
+	php7RangeStart = &version.Version{Major: 7}
+	php7RangeEnd   = &version.Version{Major: 7, Minor: 4}
 )
 
 // Parser interface
@@ -15,29 +28,26 @@ type Parser interface {
 	GetRootNode() ast.Vertex
 }
 
-type Config struct {
-	WithTokens       bool
-	WithPositions    bool
-	ErrorHandlerFunc func(e *errors.Error)
-}
-
-func Parse(src []byte, ver string, cfg Config) (ast.Vertex, error) {
+func Parse(src []byte, config cfg.Config) (ast.Vertex, error) {
 	var parser Parser
 
-	r, err := version.Compare(ver, "7.0")
-	if err != nil {
-		return nil, err
+	if config.Version == nil {
+		config.Version = php7RangeEnd
 	}
 
-	lexer := scanner.NewLexer(src, ver, cfg.ErrorHandlerFunc)
-
-	if r == -1 {
-		parser = php5.NewParser(lexer, cfg.ErrorHandlerFunc)
-	} else {
-		parser = php7.NewParser(lexer, cfg.ErrorHandlerFunc)
+	if config.Version.InRange(php5RangeStart, php5RangeEnd) {
+		lexer := scanner.NewLexer(src, config)
+		parser = php5.NewParser(lexer, config)
+		parser.Parse()
+		return parser.GetRootNode(), nil
 	}
 
-	parser.Parse()
+	if config.Version.InRange(php7RangeStart, php7RangeEnd) {
+		lexer := scanner.NewLexer(src, config)
+		parser = php7.NewParser(lexer, config)
+		parser.Parse()
+		return parser.GetRootNode(), nil
+	}
 
-	return parser.GetRootNode(), nil
+	return nil, ErrVersionOutOfRange
 }
diff --git a/pkg/version/version.go b/pkg/version/version.go
new file mode 100644
index 0000000..632baeb
--- /dev/null
+++ b/pkg/version/version.go
@@ -0,0 +1,102 @@
+package version
+
+import (
+	"errors"
+	"strconv"
+	"strings"
+)
+
+type Version struct {
+	Major, Minor uint64
+}
+
+var (
+	// ErrInvalidSemVer is returned if a version can not be parsed
+	ErrInvalidSemVer = errors.New("invalid semantic version")
+
+	// ErrUnsupportedVer is returned if a version out of supported range
+	ErrUnsupportedVer = errors.New("the version is out of supported range")
+
+	php5RangeStart = &Version{Major: 5}
+	php5RangeEnd   = &Version{Major: 5, Minor: 6}
+
+	php7RangeStart = &Version{Major: 7}
+	php7RangeEnd   = &Version{Major: 7, Minor: 4}
+)
+
+func New(v string) (*Version, error) {
+	// Split the parts into [0]Major, [1]Minor
+	parts := strings.SplitN(v, ".", 2)
+	if len(parts) != 2 {
+		return nil, ErrInvalidSemVer
+	}
+
+	var ver = new(Version)
+	var err error
+
+	ver.Major, err = strconv.ParseUint(parts[0], 10, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	ver.Minor, err = strconv.ParseUint(parts[1], 10, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	return ver, nil
+}
+
+func (v *Version) Validate() error {
+	if !v.InRange(php5RangeStart, php5RangeEnd) && !v.InRange(php7RangeStart, php7RangeEnd) {
+		return ErrUnsupportedVer
+	}
+
+	return nil
+}
+
+// Less tests if one version is less than another one
+func (v *Version) Less(o *Version) bool {
+	return v.Compare(o) < 0
+}
+
+// LessOrEqual tests if one version is less than another one or equal
+func (v *Version) LessOrEqual(o *Version) bool {
+	return v.Compare(o) <= 0
+}
+
+// Greater tests if one version is greater than another one
+func (v *Version) Greater(o *Version) bool {
+	return v.Compare(o) > 0
+}
+
+// GreaterOrEqual tests if one version is greater than another one or equal
+func (v *Version) GreaterOrEqual(o *Version) bool {
+	return v.Compare(o) >= 0
+}
+
+// GreaterOrEqual tests if one version is greater than another one or equal
+func (v *Version) InRange(s, e *Version) bool {
+	return v.Compare(s) >= 0 && v.Compare(e) <= 0
+}
+
+// Compare compares this version to another one. It returns -1, 0, or 1 if
+// the version smaller, equal, or larger than the other version.
+func (v *Version) Compare(o *Version) int {
+	if d := compareSegment(v.Major, o.Major); d != 0 {
+		return d
+	}
+
+	return compareSegment(v.Minor, o.Minor)
+}
+
+func compareSegment(v, o uint64) int {
+	if v < o {
+		return -1
+	}
+	if v > o {
+		return 1
+	}
+
+	return 0
+}
diff --git a/pkg/version/version_test.go b/pkg/version/version_test.go
new file mode 100644
index 0000000..a2bde8b
--- /dev/null
+++ b/pkg/version/version_test.go
@@ -0,0 +1,48 @@
+package version_test
+
+import (
+	"gotest.tools/assert"
+	"testing"
+
+	"github.com/z7zmey/php-parser/pkg/version"
+)
+
+func Test(t *testing.T) {
+	ver, err := version.New("7.4")
+	assert.NilError(t, err)
+
+	assert.Equal(t, *ver, version.Version{
+		Major: 7,
+		Minor: 4,
+	})
+}
+
+func TestLeadingZero(t *testing.T) {
+	ver, err := version.New("07.04")
+	assert.NilError(t, err)
+
+	assert.Equal(t, *ver, version.Version{
+		Major: 7,
+		Minor: 4,
+	})
+}
+
+func TestInRange(t *testing.T) {
+	s, err := version.New("7.0")
+	assert.NilError(t, err)
+
+	e, err := version.New("7.4")
+	assert.NilError(t, err)
+
+	ver, err := version.New("7.0")
+	assert.NilError(t, err)
+	assert.Assert(t, ver.InRange(s, e))
+
+	ver, err = version.New("7.2")
+	assert.NilError(t, err)
+	assert.Assert(t, ver.InRange(s, e))
+
+	ver, err = version.New("7.4")
+	assert.NilError(t, err)
+	assert.Assert(t, ver.InRange(s, e))
+}
diff --git a/pkg/visitor/printer/printer_php5_test.go b/pkg/visitor/printer/printer_php5_test.go
index 69a8460..f73a055 100644
--- a/pkg/visitor/printer/printer_php5_test.go
+++ b/pkg/visitor/printer/printer_php5_test.go
@@ -2,18 +2,25 @@ package printer_test
 
 import (
 	"bytes"
-	printer2 "github.com/z7zmey/php-parser/pkg/visitor/printer"
 	"testing"
 
-	"github.com/z7zmey/php-parser/pkg/ast"
-
 	"github.com/z7zmey/php-parser/internal/php5"
 	"github.com/z7zmey/php-parser/internal/scanner"
+	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
+	"github.com/z7zmey/php-parser/pkg/version"
+	"github.com/z7zmey/php-parser/pkg/visitor/printer"
 )
 
 func parsePhp5(src string) ast.Vertex {
-	lexer := scanner.NewLexer([]byte(src), "5.6", nil)
-	php5parser := php5.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 5,
+			Minor: 6,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php5parser := php5.NewParser(lexer, config)
 	php5parser.Parse()
 
 	return php5parser.GetRootNode()
@@ -22,8 +29,8 @@ func parsePhp5(src string) ast.Vertex {
 func printPhp5(n ast.Vertex) string {
 	o := bytes.NewBufferString("")
 
-	printer := printer2.NewPrinter(o)
-	n.Accept(printer)
+	p := printer.NewPrinter(o)
+	n.Accept(p)
 
 	return o.String()
 }
diff --git a/pkg/visitor/printer/printer_php7_test.go b/pkg/visitor/printer/printer_php7_test.go
index 1039390..3aceb4d 100644
--- a/pkg/visitor/printer/printer_php7_test.go
+++ b/pkg/visitor/printer/printer_php7_test.go
@@ -2,13 +2,15 @@ package printer_test
 
 import (
 	"bytes"
-	printer2 "github.com/z7zmey/php-parser/pkg/visitor/printer"
 	"os"
 	"testing"
 
 	"github.com/z7zmey/php-parser/internal/php7"
 	"github.com/z7zmey/php-parser/internal/scanner"
 	"github.com/z7zmey/php-parser/pkg/ast"
+	"github.com/z7zmey/php-parser/pkg/cfg"
+	"github.com/z7zmey/php-parser/pkg/version"
+	"github.com/z7zmey/php-parser/pkg/visitor/printer"
 )
 
 func ExamplePrinter() {
@@ -28,8 +30,14 @@ abstract class Bar extends Baz
 
 	// parse
 
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 
 	rootNode := php7parser.GetRootNode()
@@ -41,8 +49,8 @@ abstract class Bar extends Baz
 
 	// print
 
-	printer := printer2.NewPrinter(os.Stdout)
-	rootNode.Accept(printer)
+	p := printer.NewPrinter(os.Stdout)
+	rootNode.Accept(p)
 
 	// Output:
 	//<?php
@@ -60,8 +68,14 @@ abstract class Bar extends Baz
 }
 
 func parse(src string) ast.Vertex {
-	lexer := scanner.NewLexer([]byte(src), "7.4", nil)
-	php7parser := php7.NewParser(lexer, nil)
+	config := cfg.Config{
+		Version: &version.Version{
+			Major: 7,
+			Minor: 4,
+		},
+	}
+	lexer := scanner.NewLexer([]byte(src), config)
+	php7parser := php7.NewParser(lexer, config)
 	php7parser.Parse()
 
 	return php7parser.GetRootNode()
@@ -70,8 +84,8 @@ func parse(src string) ast.Vertex {
 func print(n ast.Vertex) string {
 	o := bytes.NewBufferString("")
 
-	printer := printer2.NewPrinter(o)
-	n.Accept(printer)
+	p := printer.NewPrinter(o)
+	n.Accept(p)
 
 	return o.String()
 }