trim $ from variable name identifier

node/expr/assign/t_assign_op_test.go

@@ -36,8 +36,8 @@ func TestAssignRef(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.AssignRef{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -57,7 +57,7 @@ func TestAssignRefNew(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.AssignRef{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Expression: &expr.New{
 						Class: &name.Name{
 							Parts: []node.Node{
@@ -84,7 +84,7 @@ func TestAssignRefArgs(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.AssignRef{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Expression: &expr.New{
 						Class: &name.Name{
 							Parts: []node.Node{
@@ -95,7 +95,7 @@ func TestAssignRefArgs(t *testing.T) {
 							&node.Argument{
 								Variadic:    false,
 								IsReference: false,
-								Expr:        &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+								Expr:        &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 							},
 						},
 					},
@@ -118,8 +118,8 @@ func TestAssign(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Assign{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -139,8 +139,8 @@ func TestBitwiseAnd(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.BitwiseAnd{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -160,8 +160,8 @@ func TestBitwiseOr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.BitwiseOr{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -181,8 +181,8 @@ func TestBitwiseXor(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.BitwiseXor{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -202,8 +202,8 @@ func TestConcat(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Concat{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -223,8 +223,8 @@ func TestDiv(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Div{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -244,8 +244,8 @@ func TestMinus(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Minus{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -265,8 +265,8 @@ func TestMod(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Mod{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -286,8 +286,8 @@ func TestMul(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Mul{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -307,8 +307,8 @@ func TestPlus(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Plus{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -328,8 +328,8 @@ func TestPow(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.Pow{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -349,8 +349,8 @@ func TestShiftLeft(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.ShiftLeft{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -370,8 +370,8 @@ func TestShiftRight(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &assign.ShiftRight{
-					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},

node/expr/assign/t_visitor_test.go

@@ -20,112 +20,112 @@ var nodesToTest = []struct {
 }{
 	{
 		&assign.AssignRef{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Assign{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.BitwiseAnd{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.BitwiseOr{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.BitwiseXor{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Concat{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Div{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Minus{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Mod{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Mul{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Plus{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.Pow{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.ShiftLeft{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},
 	},
 	{
 		&assign.ShiftRight{
-			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Variable:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Variable", "Expression"},
 		map[string]interface{}{},

node/expr/binary/t_binary_op_test.go

@@ -34,8 +34,8 @@ func TestBitwiseAnd(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.BitwiseAnd{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -55,8 +55,8 @@ func TestBitwiseOr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.BitwiseOr{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -76,8 +76,8 @@ func TestBitwiseXor(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.BitwiseXor{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -97,8 +97,8 @@ func TestBooleanAnd(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.BooleanAnd{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -118,8 +118,8 @@ func TestBooleanOr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.BooleanOr{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -139,8 +139,8 @@ func TestCoalesce(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Coalesce{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -157,8 +157,8 @@ func TestConcat(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Concat{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -178,8 +178,8 @@ func TestDiv(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Div{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -199,8 +199,8 @@ func TestEqual(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Equal{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -220,8 +220,8 @@ func TestGreaterOrEqual(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.GreaterOrEqual{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -241,8 +241,8 @@ func TestGreater(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Greater{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -262,8 +262,8 @@ func TestIdentical(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Identical{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -283,8 +283,8 @@ func TestLogicalAnd(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.LogicalAnd{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -304,8 +304,8 @@ func TestLogicalOr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.LogicalOr{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -325,8 +325,8 @@ func TestLogicalXor(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.LogicalXor{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -346,8 +346,8 @@ func TestMinus(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Minus{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -367,8 +367,8 @@ func TestMod(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Mod{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -388,8 +388,8 @@ func TestMul(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Mul{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -409,8 +409,8 @@ func TestNotEqual(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.NotEqual{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -430,8 +430,8 @@ func TestNotIdentical(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.NotIdentical{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -451,8 +451,8 @@ func TestPlus(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Plus{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -472,8 +472,8 @@ func TestPow(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Pow{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -493,8 +493,8 @@ func TestShiftLeft(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.ShiftLeft{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -514,8 +514,8 @@ func TestShiftRight(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.ShiftRight{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -535,8 +535,8 @@ func TestSmallerOrEqual(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.SmallerOrEqual{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -556,8 +556,8 @@ func TestSmaller(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Smaller{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -577,8 +577,8 @@ func TestSpaceship(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &binary.Spaceship{
-					Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},

node/expr/binary/t_visitor_test.go

@@ -19,216 +19,216 @@ var nodesToTest = []struct {
 }{
 	{
 		&binary.BitwiseAnd{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.BitwiseOr{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.BitwiseXor{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.BooleanAnd{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.BooleanOr{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Coalesce{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Concat{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Div{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Equal{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.GreaterOrEqual{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Greater{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Identical{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.LogicalAnd{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.LogicalOr{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.LogicalXor{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Minus{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Mod{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Mul{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.NotEqual{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.NotIdentical{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Plus{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Pow{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.ShiftLeft{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.ShiftRight{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.SmallerOrEqual{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Smaller{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},
 	},
 	{
 		&binary.Spaceship{
-			Left:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Right: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Left:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Right: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Left", "Right"},
 		map[string]interface{}{},

node/expr/cast/t_cast_test.go

@@ -34,7 +34,7 @@ func TestCastArray(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastArray{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -54,7 +54,7 @@ func TestCastBool(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastBool{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -74,7 +74,7 @@ func TestCastBoolShort(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastBool{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -94,7 +94,7 @@ func TestCastDouble(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastDouble{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -114,7 +114,7 @@ func TestCastFloat(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastDouble{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -134,7 +134,7 @@ func TestCastInt(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastInt{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -154,7 +154,7 @@ func TestCastIntShort(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastInt{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -174,7 +174,7 @@ func TestCastObject(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastObject{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -194,7 +194,7 @@ func TestCastString(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastString{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -214,7 +214,7 @@ func TestCastUnset(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &cast.CastUnset{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/cast/t_visitor_test.go

@@ -19,49 +19,49 @@ var nodesToTest = []struct {
 }{
 	{
 		&cast.CastArray{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&cast.CastBool{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&cast.CastDouble{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&cast.CastInt{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&cast.CastObject{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&cast.CastString{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&cast.CastUnset{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},

node/expr/t_array_dim_fetch_test.go

@@ -35,7 +35,7 @@ func TestArrayDimFetch(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.ArrayDimFetch{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Dim:      &scalar.Lnumber{Value: "1"},
 				},
 			},
@@ -57,7 +57,7 @@ func TestArrayDimFetchNested(t *testing.T) {
 			&stmt.Expression{
 				Expr: &expr.ArrayDimFetch{
 					Variable: &expr.ArrayDimFetch{
-						Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+						Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 						Dim:      &scalar.Lnumber{Value: "1"},
 					},
 					Dim: &scalar.Lnumber{Value: "2"},

node/expr/t_array_test.go

@@ -74,7 +74,7 @@ func TestArrayItems(t *testing.T) {
 						},
 						&expr.ArrayItem{
 							ByRef: true,
-							Val:   &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+							Val:   &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 						},
 					},
 				},

node/expr/t_bitwise_not_test.go

@@ -19,7 +19,7 @@ func TestBitwiseNot(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.BitwiseNot{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_boolean_not_test.go

@@ -19,7 +19,7 @@ func TestBooleanNot(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.BooleanNot{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_clone_test.go

@@ -19,7 +19,7 @@ func TestCloneBrackets(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Clone{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -39,7 +39,7 @@ func TestClone(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Clone{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_closure_test.go

@@ -52,22 +52,22 @@ func TestClosureUse(t *testing.T) {
 						&node.Parameter{
 							ByRef:    false,
 							Variadic: false,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 						},
 						&node.Parameter{
 							ByRef:    false,
 							Variadic: false,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 						},
 					},
 					Uses: []node.Node{
 						&expr.ClosureUse{
 							ByRef:    false,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
 						},
 						&expr.ClosureUse{
 							ByRef:    true,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$d"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "d"}},
 						},
 					},
 					Stmts: []node.Node{},
@@ -97,22 +97,22 @@ func TestClosureUse2(t *testing.T) {
 						&node.Parameter{
 							ByRef:    false,
 							Variadic: false,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 						},
 						&node.Parameter{
 							ByRef:    false,
 							Variadic: false,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 						},
 					},
 					Uses: []node.Node{
 						&expr.ClosureUse{
 							ByRef:    true,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "c"}},
 						},
 						&expr.ClosureUse{
 							ByRef:    false,
-							Variable: &expr.Variable{VarName: &node.Identifier{Value: "$d"}},
+							Variable: &expr.Variable{VarName: &node.Identifier{Value: "d"}},
 						},
 					},
 					Stmts: []node.Node{},

node/expr/t_empty_test.go

@@ -19,7 +19,7 @@ func TestEmpty(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Empty{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_error_supress_test.go

@@ -19,7 +19,7 @@ func TestErrorSuppress(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.ErrorSuppress{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_eval_test.go

@@ -19,7 +19,7 @@ func TestEval(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Eval{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_exit_test.go

@@ -37,7 +37,7 @@ func TestExitExpr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Exit{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -75,7 +75,7 @@ func TestDieExpr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Die{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_function_call_test.go

@@ -104,13 +104,13 @@ func TestFunctionCallVar(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.FunctionCall{
-					Function: &expr.Variable{VarName: &node.Identifier{Value: "$foo"}},
+					Function: &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
 					Arguments: []node.Node{
 						&node.Argument{
 							Variadic:    false,
 							IsReference: false,
 							Expr: &expr.Yield{
-								Value: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+								Value: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 							},
 						},
 					},

node/expr/t_inc_dec_test.go

@@ -19,7 +19,7 @@ func TestPostDec(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.PostDec{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -39,7 +39,7 @@ func TestPostInc(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.PostInc{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -59,7 +59,7 @@ func TestPreDec(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.PreDec{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -79,7 +79,7 @@ func TestPreInc(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.PreInc{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_include_test.go

@@ -19,7 +19,7 @@ func TestInclude(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Include{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -39,7 +39,7 @@ func TestIncludeOnce(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.IncludeOnce{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -59,7 +59,7 @@ func TestRequire(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Require{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -79,7 +79,7 @@ func TestRequireOnce(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.RequireOnce{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_instance_of_test.go

@@ -21,7 +21,7 @@ func TestInstanceOf(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.InstanceOf{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Class: &name.Name{
 						Parts: []node.Node{
 							&name.NamePart{Value: "Foo"},
@@ -46,7 +46,7 @@ func TestInstanceOfRelative(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.InstanceOf{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Class: &name.Relative{
 						Parts: []node.Node{
 							&name.NamePart{Value: "Foo"},
@@ -71,7 +71,7 @@ func TestInstanceOfFullyQualified(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.InstanceOf{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Class: &name.FullyQualified{
 						Parts: []node.Node{
 							&name.NamePart{Value: "Foo"},

node/expr/t_isset_test.go

@@ -20,7 +20,7 @@ func TestIsset(t *testing.T) {
 			&stmt.Expression{
 				Expr: &expr.Isset{
 					Variables: []node.Node{
-						&expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+						&expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					},
 				},
 			},
@@ -42,8 +42,8 @@ func TestIssetVariables(t *testing.T) {
 			&stmt.Expression{
 				Expr: &expr.Isset{
 					Variables: []node.Node{
-						&expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-						&expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+						&expr.Variable{VarName: &node.Identifier{Value: "a"}},
+						&expr.Variable{VarName: &node.Identifier{Value: "b"}},
 					},
 				},
 			},

node/expr/t_list_test.go

@@ -24,7 +24,7 @@ func TestEmptyList(t *testing.T) {
 					Variable: &expr.List{
 						Items: []node.Node{},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -48,11 +48,11 @@ func TestList(t *testing.T) {
 						Items: []node.Node{
 							&expr.ArrayItem{
 								ByRef: false,
-								Val:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+								Val:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 							},
 						},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -77,12 +77,12 @@ func TestListArrayIndex(t *testing.T) {
 							&expr.ArrayItem{
 								ByRef: false,
 								Val: &expr.ArrayDimFetch{
-									Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+									Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 								},
 							},
 						},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -110,14 +110,14 @@ func TestListList(t *testing.T) {
 									Items: []node.Node{
 										&expr.ArrayItem{
 											ByRef: false,
-											Val:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+											Val:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 										},
 									},
 								},
 							},
 						},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},

node/expr/t_method_call_test.go

@@ -19,7 +19,7 @@ func TestMethodCall(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.MethodCall{
-					Variable:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Method:    &node.Identifier{Value: "foo"},
 					Arguments: []node.Node{},
 				},

node/expr/t_new_test.go

@@ -98,8 +98,8 @@ func TestNewAnonymous(t *testing.T) {
 					Class: &stmt.Class{
 						PhpDocComment: "",
 						Args: []node.Node{
-							&node.Argument{Variadic: false, Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}}},
-							&node.Argument{Variadic: true, Expr: &expr.Variable{VarName: &node.Identifier{Value: "$b"}}},
+							&node.Argument{Variadic: false, Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
+							&node.Argument{Variadic: true, Expr: &expr.Variable{VarName: &node.Identifier{Value: "b"}}},
 						},
 						Stmts: []node.Node{},
 					},

node/expr/t_print_test.go

@@ -19,7 +19,7 @@ func TestPrint(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Print{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_property_fetch_test.go

@@ -19,7 +19,7 @@ func TestPropertyFetch(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.PropertyFetch{
-					Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Property: &node.Identifier{Value: "foo"},
 				},
 			},

node/expr/t_shell_exec_test.go

@@ -23,7 +23,7 @@ func TestShellExec(t *testing.T) {
 				Expr: &expr.ShellExec{
 					Parts: []node.Node{
 						&scalar.EncapsedStringPart{Value: "cmd "},
-						&expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+						&expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					},
 				},
 			},

node/expr/t_short_array_test.go

@@ -74,7 +74,7 @@ func TestShortArrayItems(t *testing.T) {
 						},
 						&expr.ArrayItem{
 							ByRef: true,
-							Val:   &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+							Val:   &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 						},
 					},
 				},

node/expr/t_short_list_test.go

@@ -24,11 +24,11 @@ func TestShortList(t *testing.T) {
 						Items: []node.Node{
 							&expr.ArrayItem{
 								ByRef: false,
-								Val:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+								Val:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 							},
 						},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -50,12 +50,12 @@ func TestShortListArrayIndex(t *testing.T) {
 							&expr.ArrayItem{
 								ByRef: false,
 								Val: &expr.ArrayDimFetch{
-									Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+									Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 								},
 							},
 						},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -80,14 +80,14 @@ func TestShortListList(t *testing.T) {
 									Items: []node.Node{
 										&expr.ArrayItem{
 											ByRef: false,
-											Val:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+											Val:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 										},
 									},
 								},
 							},
 						},
 					},
-					Expression: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Expression: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},

node/expr/t_static_call_test.go

@@ -104,7 +104,7 @@ func TestStaticCallVar(t *testing.T) {
 							&name.NamePart{Value: "Foo"},
 						},
 					},
-					Call:      &expr.Variable{VarName: &node.Identifier{Value: "$bar"}},
+					Call:      &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
 					Arguments: []node.Node{},
 				},
 			},
@@ -125,8 +125,8 @@ func TestStaticCallVarVar(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.StaticCall{
-					Class:     &expr.Variable{VarName: &node.Identifier{Value: "$foo"}},
-					Call:      &expr.Variable{VarName: &node.Identifier{Value: "$bar"}},
+					Class:     &expr.Variable{VarName: &node.Identifier{Value: "foo"}},
+					Call:      &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
 					Arguments: []node.Node{},
 				},
 			},

node/expr/t_static_property_fetch_test.go

@@ -25,7 +25,7 @@ func TestStaticPropertyFetch(t *testing.T) {
 							&name.NamePart{Value: "Foo"},
 						},
 					},
-					Property: &expr.Variable{VarName: &node.Identifier{Value: "$bar"}},
+					Property: &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
 				},
 			},
 		},
@@ -50,7 +50,7 @@ func TestStaticPropertyFetchRelative(t *testing.T) {
 							&name.NamePart{Value: "Foo"},
 						},
 					},
-					Property: &expr.Variable{VarName: &node.Identifier{Value: "$bar"}},
+					Property: &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
 				},
 			},
 		},
@@ -75,7 +75,7 @@ func TestStaticPropertyFetchFullyQualified(t *testing.T) {
 							&name.NamePart{Value: "Foo"},
 						},
 					},
-					Property: &expr.Variable{VarName: &node.Identifier{Value: "$bar"}},
+					Property: &expr.Variable{VarName: &node.Identifier{Value: "bar"}},
 				},
 			},
 		},

node/expr/t_ternary_test.go

@@ -19,9 +19,9 @@ func TestTernary(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Ternary{
-					Condition: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
-					IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
+					Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+					IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "c"}},
 				},
 			},
 		},
@@ -41,8 +41,8 @@ func TestTernarySimple(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Ternary{
-					Condition: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
+					Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "c"}},
 				},
 			},
 		},
@@ -62,13 +62,13 @@ func TestTernaryNestedTrue(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Ternary{
-					Condition: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					IfTrue: &expr.Ternary{
-						Condition: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
-						IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
-						IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "$d"}},
+						Condition: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+						IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "c"}},
+						IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "d"}},
 					},
-					IfFalse: &expr.Variable{VarName: &node.Identifier{Value: "$e"}},
+					IfFalse: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
 				},
 			},
 		},
@@ -89,12 +89,12 @@ func TestTernaryNestedCond(t *testing.T) {
 			&stmt.Expression{
 				Expr: &expr.Ternary{
 					Condition: &expr.Ternary{
-						Condition: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-						IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
-						IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
+						Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+						IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+						IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "c"}},
 					},
-					IfTrue:  &expr.Variable{VarName: &node.Identifier{Value: "$d"}},
-					IfFalse: &expr.Variable{VarName: &node.Identifier{Value: "$e"}},
+					IfTrue:  &expr.Variable{VarName: &node.Identifier{Value: "d"}},
+					IfFalse: &expr.Variable{VarName: &node.Identifier{Value: "e"}},
 				},
 			},
 		},

node/expr/t_unary_test.go

@@ -19,7 +19,7 @@ func TestUnaryMinus(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.UnaryMinus{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -39,7 +39,7 @@ func TestUnaryPlus(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.UnaryPlus{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},

node/expr/t_variable_test.go

@@ -18,7 +18,7 @@ func TestVariable(t *testing.T) {
 	expected := &stmt.StmtList{
 		Stmts: []node.Node{
 			&stmt.Expression{
-				Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+				Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			},
 		},
 	}
@@ -36,7 +36,7 @@ func TestVariableVariable(t *testing.T) {
 	expected := &stmt.StmtList{
 		Stmts: []node.Node{
 			&stmt.Expression{
-				Expr: &expr.Variable{VarName: &expr.Variable{VarName: &node.Identifier{Value: "$a"}}},
+				Expr: &expr.Variable{VarName: &expr.Variable{VarName: &node.Identifier{Value: "a"}}},
 			},
 		},
 	}

node/expr/t_visitor_test.go

@@ -24,7 +24,7 @@ var nodesToTest = []struct {
 }{
 	{
 		&expr.ArrayDimFetch{
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			Dim:      &scalar.Lnumber{Value: "1"},
 		},
 		[]string{"Variable", "Dim"},
@@ -54,21 +54,21 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.BitwiseNot{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.BooleanNot{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.ClassConstFetch{
-			Class:        &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Class:        &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			ConstantName: &node.Identifier{Value: "foo"},
 		},
 		[]string{"Class", "ConstantName"},
@@ -76,7 +76,7 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.Clone{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
@@ -84,7 +84,7 @@ var nodesToTest = []struct {
 	{
 		&expr.ClosureUse{
 			ByRef:    false,
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Variable"},
 		map[string]interface{}{"ByRef": false},
@@ -111,42 +111,42 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.Empty{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.ErrorSuppress{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Eval{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Exit{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Die{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.FunctionCall{
-			Function:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Function:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			Arguments: []node.Node{&node.Argument{}},
 		},
 		[]string{"Function", "Arguments"},
@@ -154,21 +154,21 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.IncludeOnce{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Include{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.InstanceOf{
-			Expr:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			Class: &name.Name{},
 		},
 		[]string{"Expr", "Class"},
@@ -177,7 +177,7 @@ var nodesToTest = []struct {
 	{
 		&expr.Isset{
 			Variables: []node.Node{
-				&expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+				&expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			},
 		},
 		[]string{"Variables"},
@@ -194,7 +194,7 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.MethodCall{
-			Variable:  &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable:  &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			Method:    &node.Identifier{Value: "foo"},
 			Arguments: []node.Node{&node.Argument{}},
 		},
@@ -211,42 +211,42 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.PostDec{
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Variable"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.PostInc{
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Variable"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.PreDec{
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Variable"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.PreInc{
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Variable"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Print{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.PropertyFetch{
-			Variable: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Variable: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 			Property: &node.Identifier{Value: "foo"},
 		},
 		[]string{"Variable", "Property"},
@@ -254,14 +254,14 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.RequireOnce{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Require{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
@@ -312,43 +312,43 @@ var nodesToTest = []struct {
 	},
 	{
 		&expr.Ternary{
-			Condition: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
-			IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "$c"}},
+			Condition: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			IfTrue:    &expr.Variable{VarName: &node.Identifier{Value: "b"}},
+			IfFalse:   &expr.Variable{VarName: &node.Identifier{Value: "c"}},
 		},
 		[]string{"Condition", "IfTrue", "IfFalse"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.UnaryMinus{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.UnaryPlus{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
-		&expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+		&expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		[]string{"VarName"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.YieldFrom{
-			Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+			Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 		},
 		[]string{"Expr"},
 		map[string]interface{}{},
 	},
 	{
 		&expr.Yield{
-			Key:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-			Value: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+			Key:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+			Value: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 		},
 		[]string{"Key", "Value"},
 		map[string]interface{}{},

node/expr/t_yield_test.go

@@ -38,7 +38,7 @@ func TestYieldVal(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Yield{
-					Value: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Value: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},
@@ -58,8 +58,8 @@ func TestYieldKeyVal(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Yield{
-					Key:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
-					Value: &expr.Variable{VarName: &node.Identifier{Value: "$b"}},
+					Key:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
+					Value: &expr.Variable{VarName: &node.Identifier{Value: "b"}},
 				},
 			},
 		},
@@ -99,7 +99,7 @@ func TestYieldKeyExpr(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.Yield{
-					Key:   &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Key:   &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 					Value: &scalar.Lnumber{Value: "1"},
 				},
 			},
@@ -120,7 +120,7 @@ func TestYieldFrom(t *testing.T) {
 		Stmts: []node.Node{
 			&stmt.Expression{
 				Expr: &expr.YieldFrom{
-					Expr: &expr.Variable{VarName: &node.Identifier{Value: "$a"}},
+					Expr: &expr.Variable{VarName: &node.Identifier{Value: "a"}},
 				},
 			},
 		},