979 lines
22 KiB
Go
979 lines
22 KiB
Go
package core
|
|
|
|
import (
|
|
"math/big"
|
|
"strconv"
|
|
"testing"
|
|
)
|
|
|
|
func TestNewParser(t *testing.T) {
|
|
tokens := make([]Token, 0)
|
|
|
|
p := NewParser("", []string{}, tokens)
|
|
|
|
if p == nil {
|
|
t.Fatal("parser should not be nil")
|
|
}
|
|
|
|
if p.pos != 0 {
|
|
t.Error("parser should initialize position at 0")
|
|
}
|
|
|
|
if len(p.tokens) != len(tokens) {
|
|
t.Error("parser should have the passed token list")
|
|
}
|
|
|
|
for i, v := range tokens {
|
|
if p.tokens[i] != v {
|
|
t.Error("parser should have the passed token list")
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkNewParser(b *testing.B) {
|
|
tokens := make([]Token, 0)
|
|
for i := 0; i < b.N; i++ {
|
|
_ = NewParser("", []string{}, tokens)
|
|
}
|
|
}
|
|
|
|
type TokenTestData struct {
|
|
tokens []Token
|
|
tree Node
|
|
}
|
|
|
|
func GetTokenTestData() map[string]TokenTestData {
|
|
return map[string]TokenTestData{
|
|
"empty": {
|
|
[]Token{
|
|
NewToken(TokenEOF, 0, 0, 0, ""),
|
|
},
|
|
&BlockNode{},
|
|
},
|
|
"addition": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 1, 0, "_"),
|
|
NewToken(TokenAssign, 1, 1, 0, "="),
|
|
NewToken(TokenFloat, 3, 1, 0, "1"),
|
|
NewToken(TokenPlus, 4, 1, 0, "+"),
|
|
NewToken(TokenFloat, 5, 1, 0, "2"),
|
|
NewToken(TokenEOF, 6, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"_", 0, 0},
|
|
&BinaryNode{
|
|
BinaryAddition,
|
|
&FloatNode{
|
|
1,
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
2,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"assignment": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 5, 0, "hello"),
|
|
NewToken(TokenAssign, 5, 1, 0, "="),
|
|
NewToken(TokenString, 6, 12, 0, "\"Hello world!\""),
|
|
NewToken(TokenEOF, 18, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"hello", 0, 0},
|
|
&StringNode{
|
|
"Hello world!",
|
|
"\"Hello world!\"",
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"declaration": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 1, 0, "a"),
|
|
NewToken(TokenDeclare, 1, 2, 0, ":="),
|
|
NewToken(TokenFloat, 3, 1, 0, "1"),
|
|
NewToken(TokenPlus, 4, 1, 0, "+"),
|
|
NewToken(TokenName, 5, 1, 0, "b"),
|
|
NewToken(TokenEOF, 6, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"a", 0, 0},
|
|
&BinaryNode{
|
|
BinaryAddition,
|
|
&FloatNode{
|
|
1,
|
|
0, 0,
|
|
},
|
|
&ReferenceNode{
|
|
"b",
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
true,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
// (2 + 1) * 5 + 3 / (6 - 2) - 10 / 2
|
|
"arithmetic_order": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 1, 0, "_"),
|
|
NewToken(TokenAssign, 1, 2, 0, "="),
|
|
|
|
NewToken(TokenOpenParenthesis, 3, 1, 0, "("),
|
|
NewToken(TokenFloat, 4, 1, 0, "2"),
|
|
NewToken(TokenPlus, 5, 1, 0, "+"),
|
|
NewToken(TokenFloat, 6, 1, 0, "1"),
|
|
NewToken(TokenCloseParenthesis, 7, 1, 0, ")"),
|
|
NewToken(TokenStar, 8, 1, 0, "*"),
|
|
NewToken(TokenFloat, 9, 1, 0, "5"),
|
|
|
|
NewToken(TokenPlus, 10, 1, 0, "+"),
|
|
|
|
NewToken(TokenFloat, 11, 1, 0, "3"),
|
|
NewToken(TokenSlash, 12, 1, 0, "/"),
|
|
NewToken(TokenOpenParenthesis, 13, 1, 0, "("),
|
|
NewToken(TokenFloat, 14, 1, 0, "6"),
|
|
NewToken(TokenMinus, 15, 1, 0, "-"),
|
|
NewToken(TokenFloat, 16, 1, 0, "2"),
|
|
NewToken(TokenCloseParenthesis, 17, 1, 0, ")"),
|
|
|
|
NewToken(TokenMinus, 18, 1, 0, "-"),
|
|
|
|
NewToken(TokenFloat, 19, 2, 0, "10"),
|
|
NewToken(TokenSlash, 20, 1, 0, "/"),
|
|
NewToken(TokenFloat, 21, 1, 0, "2"),
|
|
NewToken(TokenEOF, 22, 0, 0, ""),
|
|
},
|
|
// (2 + 1) * 5 + 3 / (6 - 2) - 10 / 2
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"_", 0, 0},
|
|
&BinaryNode{
|
|
BinarySubtraction,
|
|
&BinaryNode{
|
|
BinaryAddition,
|
|
&BinaryNode{
|
|
BinaryMultiplication,
|
|
&BinaryNode{
|
|
BinaryAddition,
|
|
&FloatNode{
|
|
2,
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
1,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
5,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
&BinaryNode{
|
|
BinaryDivision,
|
|
&FloatNode{
|
|
3,
|
|
0, 0,
|
|
},
|
|
&BinaryNode{
|
|
BinarySubtraction,
|
|
&FloatNode{
|
|
6,
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
2,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
&BinaryNode{
|
|
BinaryDivision,
|
|
&FloatNode{
|
|
10,
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
2,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"condition_equal": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 1, 0, "_"),
|
|
NewToken(TokenAssign, 1, 1, 0, "="),
|
|
NewToken(TokenFloat, 2, 2, 0, "20"),
|
|
NewToken(TokenEquals, 4, 2, 0, "=="),
|
|
NewToken(TokenFloat, 6, 2, 0, "15"),
|
|
NewToken(TokenEOF, 8, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"_", 0, 0},
|
|
&BinaryNode{
|
|
BinaryEquality,
|
|
&FloatNode{
|
|
20,
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
15,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"if_statement": {
|
|
[]Token{
|
|
NewToken(TokenIf, 0, 2, 0, "if"),
|
|
NewToken(TokenName, 2, 1, 0, "a"),
|
|
NewToken(TokenEquals, 3, 2, 0, "=="),
|
|
NewToken(TokenFloat, 5, 1, 0, "0"),
|
|
NewToken(TokenOpenBrace, 6, 1, 0, "{"),
|
|
NewToken(TokenName, 7, 1, 1, "b"),
|
|
NewToken(TokenAssign, 8, 1, 1, "="),
|
|
NewToken(TokenFloat, 9, 1, 1, "1"),
|
|
NewToken(TokenCloseBrace, 10, 1, 2, "}"),
|
|
NewToken(TokenEOF, 11, 0, 2, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&ConditionalNode{
|
|
condition: &BinaryNode{
|
|
BinaryEquality,
|
|
&ReferenceNode{
|
|
"a",
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
0,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
do: &BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"b", 0, 0},
|
|
&FloatNode{
|
|
1,
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"if_else_statement": {
|
|
[]Token{
|
|
NewToken(TokenIf, 0, 2, 0, "if"),
|
|
NewToken(TokenName, 2, 1, 0, "a"),
|
|
NewToken(TokenEquals, 3, 2, 0, "=="),
|
|
NewToken(TokenFloat, 5, 1, 0, "0"),
|
|
NewToken(TokenOpenBrace, 6, 1, 0, "{"),
|
|
NewToken(TokenName, 7, 1, 1, "b"),
|
|
NewToken(TokenAssign, 8, 1, 1, "="),
|
|
NewToken(TokenFloat, 9, 1, 1, "1"),
|
|
NewToken(TokenCloseBrace, 10, 1, 2, "}"),
|
|
NewToken(TokenElse, 11, 4, 2, "else"),
|
|
NewToken(TokenOpenBrace, 15, 1, 2, "{"),
|
|
NewToken(TokenName, 16, 1, 2, "b"),
|
|
NewToken(TokenAssign, 17, 1, 2, "="),
|
|
NewToken(TokenFloat, 18, 1, 2, "0"),
|
|
NewToken(TokenCloseBrace, 19, 1, 2, "}"),
|
|
NewToken(TokenEOF, 20, 0, 2, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&ConditionalNode{
|
|
condition: &BinaryNode{
|
|
BinaryEquality,
|
|
&ReferenceNode{
|
|
"a",
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
0,
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
do: &BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"b", 0, 0},
|
|
&FloatNode{
|
|
1,
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
otherwise: &BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"b", 0, 0},
|
|
&FloatNode{
|
|
0,
|
|
0, 0,
|
|
},
|
|
false,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"empty_block": {
|
|
[]Token{
|
|
NewToken(TokenOpenBrace, 0, 1, 0, "{"),
|
|
NewToken(TokenCloseBrace, 1, 1, 0, "}"),
|
|
NewToken(TokenEOF, 2, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&BlockNode{
|
|
[]Node{},
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"lambda": { // a := fn(a: float, b: float) -> float { return a + b }
|
|
[]Token{
|
|
NewToken(TokenName, 0, 1, 0, "a"),
|
|
NewToken(TokenDeclare, 1, 2, 0, ":="),
|
|
NewToken(TokenFunc, 3, 2, 0, "fn"),
|
|
NewToken(TokenOpenParenthesis, 5, 1, 0, "("),
|
|
NewToken(TokenName, 6, 1, 0, "a"),
|
|
NewToken(TokenColon, 6, 1, 0, ":"),
|
|
NewToken(TokenName, 10, 5, 0, "float"),
|
|
NewToken(TokenComma, 9, 1, 0, ","),
|
|
NewToken(TokenName, 10, 1, 0, "b"),
|
|
NewToken(TokenColon, 9, 1, 0, ":"),
|
|
NewToken(TokenName, 10, 5, 0, "float"),
|
|
NewToken(TokenCloseParenthesis, 11, 1, 0, ")"),
|
|
NewToken(TokenArrow, 12, 1, 0, "->"),
|
|
NewToken(TokenName, 10, 5, 0, "float"),
|
|
|
|
NewToken(TokenOpenBrace, 12, 1, 1, "{"),
|
|
NewToken(TokenReturn, 13, 6, 1, "return"),
|
|
NewToken(TokenName, 19, 1, 1, "a"),
|
|
NewToken(TokenPlus, 20, 1, 1, "+"),
|
|
NewToken(TokenName, 21, 1, 1, "b"),
|
|
NewToken(TokenCloseBrace, 22, 1, 2, "}"),
|
|
|
|
NewToken(TokenEOF, 23, 0, 2, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"a", 0, 0},
|
|
&FunctionNode{
|
|
"*",
|
|
[]FunctionParameter{
|
|
{
|
|
"a",
|
|
&FloatSignature{},
|
|
},
|
|
{
|
|
"b",
|
|
&FloatSignature{},
|
|
},
|
|
},
|
|
&FloatSignature{},
|
|
&BlockNode{
|
|
[]Node{
|
|
&ReturnNode{
|
|
&BinaryNode{
|
|
BinaryAddition,
|
|
&ReferenceNode{
|
|
"a",
|
|
0, 0,
|
|
},
|
|
&ReferenceNode{
|
|
"b",
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
0, 0,
|
|
},
|
|
true,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"function_declaration": {
|
|
[]Token{
|
|
NewToken(TokenFunc, 0, 2, 0, "fn"),
|
|
NewToken(TokenName, 4, 3, 0, "a"),
|
|
NewToken(TokenOpenParenthesis, 7, 1, 0, "("),
|
|
NewToken(TokenName, 8, 1, 0, "a"),
|
|
NewToken(TokenColon, 9, 1, 0, ":"),
|
|
NewToken(TokenName, 8, 1, 0, "float"),
|
|
NewToken(TokenComma, 9, 1, 0, ","),
|
|
NewToken(TokenName, 10, 1, 0, "b"),
|
|
NewToken(TokenColon, 9, 1, 0, ":"),
|
|
NewToken(TokenName, 8, 1, 0, "float"),
|
|
NewToken(TokenCloseParenthesis, 11, 1, 0, ")"),
|
|
NewToken(TokenArrow, 9, 1, 0, "->"),
|
|
NewToken(TokenName, 8, 1, 0, "float"),
|
|
|
|
NewToken(TokenOpenBrace, 12, 1, 1, "{"),
|
|
NewToken(TokenReturn, 13, 6, 1, "return"),
|
|
NewToken(TokenName, 19, 1, 1, "a"),
|
|
NewToken(TokenPlus, 20, 1, 1, "+"),
|
|
NewToken(TokenName, 21, 1, 1, "b"),
|
|
NewToken(TokenCloseBrace, 22, 1, 2, "}"),
|
|
|
|
NewToken(TokenEOF, 23, 0, 2, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"a", 0, 0},
|
|
&FunctionNode{
|
|
"a",
|
|
[]FunctionParameter{
|
|
{
|
|
"a",
|
|
&FloatSignature{},
|
|
},
|
|
{
|
|
"b",
|
|
&FloatSignature{},
|
|
},
|
|
},
|
|
&FloatSignature{},
|
|
&BlockNode{
|
|
[]Node{
|
|
&ReturnNode{
|
|
&BinaryNode{
|
|
BinaryAddition,
|
|
&ReferenceNode{
|
|
"a",
|
|
0, 0,
|
|
},
|
|
&ReferenceNode{
|
|
"b",
|
|
0, 0,
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
0, 0,
|
|
},
|
|
true,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"prop_getting": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 1, 0, "p"),
|
|
NewToken(TokenDeclare, 1, 2, 0, ":="),
|
|
NewToken(TokenName, 3, 1, 0, "a"),
|
|
NewToken(TokenDot, 4, 1, 0, "."),
|
|
NewToken(TokenName, 5, 1, 0, "b"),
|
|
|
|
NewToken(TokenEOF, 23, 0, 2, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"p", 0, 0},
|
|
&AccessNode{
|
|
&ReferenceNode{
|
|
"a",
|
|
0, 0,
|
|
},
|
|
&Token{TokenName, 0, 1, 0, "b"},
|
|
0, 0,
|
|
},
|
|
true,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"list_init": {
|
|
[]Token{
|
|
NewToken(TokenName, 0, 4, 0, "data"),
|
|
NewToken(TokenDeclare, 4, 2, 0, ":="),
|
|
|
|
NewToken(TokenOpenBracket, 6, 1, 0, "["),
|
|
NewToken(TokenName, 8, 1, 0, "a"),
|
|
NewToken(TokenComma, 11, 1, 0, ","),
|
|
|
|
NewToken(TokenFloat, 8, 1, 0, "3.141"),
|
|
NewToken(TokenComma, 11, 1, 0, ","),
|
|
|
|
NewToken(TokenString, 6, 1, 0, "\"Hello world!\""),
|
|
NewToken(TokenComma, 11, 1, 0, ","),
|
|
|
|
NewToken(TokenTrue, 6, 1, 0, "true"),
|
|
NewToken(TokenComma, 11, 1, 0, ","),
|
|
|
|
NewToken(TokenOpenBracket, 6, 1, 0, "["),
|
|
NewToken(TokenFloat, 6, 1, 0, "2"),
|
|
NewToken(TokenComma, 11, 1, 0, ","),
|
|
|
|
NewToken(TokenFloat, 6, 1, 0, "3"),
|
|
NewToken(TokenCloseBracket, 6, 1, 0, "]"),
|
|
|
|
NewToken(TokenCloseBracket, 6, 1, 0, "]"),
|
|
|
|
NewToken(TokenEOF, 23, 0, 2, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&AssignNode{
|
|
&ReferenceNode{"data", 0, 0},
|
|
&ListNode{
|
|
[]Node{
|
|
&ReferenceNode{
|
|
"a",
|
|
0, 0,
|
|
},
|
|
&FloatNode{
|
|
3.141,
|
|
0, 0,
|
|
},
|
|
&StringNode{
|
|
"Hello world!",
|
|
"\"Hello world!\"",
|
|
0, 0,
|
|
},
|
|
&BooleanNode{
|
|
true,
|
|
0, 0,
|
|
},
|
|
&ListNode{
|
|
[]Node{
|
|
&FloatNode{
|
|
2,
|
|
0, 0,
|
|
}, &FloatNode{
|
|
3,
|
|
0, 0,
|
|
},
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
},
|
|
nil,
|
|
0, 0,
|
|
},
|
|
true,
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"single_tuple": {
|
|
[]Token{
|
|
NewToken(TokenOpenParenthesis, 0, 0, 0, "("),
|
|
NewToken(TokenInteger, 0, 0, 0, "1"),
|
|
NewToken(TokenComma, 0, 0, 0, ","),
|
|
NewToken(TokenCloseParenthesis, 0, 0, 0, ")"),
|
|
NewToken(TokenEOF, 0, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&TupleNode{
|
|
[]Node{
|
|
&IntegerNode{
|
|
big.NewInt(1),
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
"tuple": {
|
|
[]Token{
|
|
NewToken(TokenOpenParenthesis, 0, 0, 0, "("),
|
|
NewToken(TokenInteger, 0, 0, 0, "1"),
|
|
NewToken(TokenComma, 0, 0, 0, ","),
|
|
NewToken(TokenInteger, 0, 0, 0, "2"),
|
|
NewToken(TokenCloseParenthesis, 0, 0, 0, ")"),
|
|
NewToken(TokenEOF, 0, 0, 0, ""),
|
|
},
|
|
&BlockNode{
|
|
[]Node{
|
|
&TupleNode{
|
|
[]Node{
|
|
&IntegerNode{
|
|
big.NewInt(1),
|
|
0, 0,
|
|
},
|
|
&IntegerNode{
|
|
big.NewInt(2),
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
0, 0,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func NodeEquality(t *testing.T, n1 Node, n2 Node) {
|
|
if n1 == n2 {
|
|
return
|
|
}
|
|
|
|
if n1 == nil || n2 == nil {
|
|
t.Fatalf("one of the nodes are nil (1: %s; 2: %s)", n1, n2)
|
|
}
|
|
|
|
if n1.Type() != n2.Type() {
|
|
t.Fatalf("node types (%s and %s) don't match", n1.Type(), n2.Type())
|
|
}
|
|
|
|
t.Logf("Nodes have same non-nil type (%s)", n1.Type())
|
|
|
|
switch n1.Type() {
|
|
case NilNodeType:
|
|
case StringNodeType:
|
|
if n1.(*StringNode).value != n2.(*StringNode).value {
|
|
t.Errorf("String node values don't match (%s and %s)", n1.(*StringNode).value, n2.(*StringNode).value)
|
|
} else {
|
|
t.Logf("String node values match (%s)", n1.(*StringNode).value)
|
|
}
|
|
|
|
if n1.(*StringNode).quoted != n2.(*StringNode).quoted {
|
|
t.Errorf("String node quoted values don't match (%s and %s)", n1.(*StringNode).quoted, n2.(*StringNode).quoted)
|
|
} else {
|
|
t.Logf("String node quoted values match (%s)", n1.(*StringNode).value)
|
|
}
|
|
|
|
case FloatNodeType:
|
|
if n1.(*FloatNode).value != n2.(*FloatNode).value {
|
|
t.Errorf("Float node values don't match (%f and %f)", n1.(*FloatNode).value, n2.(*FloatNode).value)
|
|
} else {
|
|
t.Logf("Float node values match (%f)", n1.(*FloatNode).value)
|
|
}
|
|
|
|
case IntegerNodeType:
|
|
if n1.(*IntegerNode).value.Cmp(n2.(*IntegerNode).value) != 0 {
|
|
t.Errorf("Integer node values don't match (%d and %d)", n1.(*IntegerNode).value, n2.(*IntegerNode).value)
|
|
} else {
|
|
t.Logf("Integer node values match (%d)", n1.(*IntegerNode).value)
|
|
}
|
|
|
|
case ReferenceNodeType:
|
|
if n1.(*ReferenceNode).name != n2.(*ReferenceNode).name {
|
|
t.Errorf("Reference node values don't match (%s and %s)", n1.(*ReferenceNode).name, n2.(*ReferenceNode).name)
|
|
} else {
|
|
t.Logf("Reference node values match (%s)", n1.(*ReferenceNode).name)
|
|
}
|
|
case BinaryNodeType:
|
|
if n1.(*BinaryNode).BinaryOperation != n2.(*BinaryNode).BinaryOperation {
|
|
t.Errorf("Binary node operation not same (%s and %s)", n1.(*BinaryNode).BinaryOperation, n2.(*BinaryNode).BinaryOperation)
|
|
} else {
|
|
t.Logf("Binary node operation matches (%s)", n1.(*BinaryNode).BinaryOperation)
|
|
}
|
|
|
|
t.Log("Checking equality of binary left side")
|
|
NodeEquality(t, n1.(*BinaryNode).Left, n2.(*BinaryNode).Left)
|
|
t.Log("Checking equality of binary right side")
|
|
NodeEquality(t, n1.(*BinaryNode).Right, n2.(*BinaryNode).Right)
|
|
|
|
case BooleanNodeType:
|
|
if n1.(*BooleanNode).Boolean != n2.(*BooleanNode).Boolean {
|
|
t.Errorf("Boolean node values don't match (%s and %s)", strconv.FormatBool(n1.(*BooleanNode).Boolean), strconv.FormatBool(n2.(*BooleanNode).Boolean))
|
|
} else {
|
|
t.Logf("Boolean node values match (%s)", strconv.FormatBool(n1.(*BooleanNode).Boolean))
|
|
}
|
|
case BlockNodeType:
|
|
if len(n1.(*BlockNode).statements) != len(n2.(*BlockNode).statements) {
|
|
t.Errorf("Block node statement count is not equal (%d and %d)", len(n1.(*BlockNode).statements), len(n2.(*BlockNode).statements))
|
|
} else {
|
|
t.Logf("Block node statement count is equal (%d) ", len(n1.(*BlockNode).statements))
|
|
}
|
|
|
|
for i, n := range n1.(*BlockNode).statements {
|
|
t.Logf("Checking equality of statements at %d", i)
|
|
NodeEquality(t, n, n2.(*BlockNode).statements[i])
|
|
}
|
|
|
|
case ConditionalNodeType:
|
|
t.Log("Checking equality of conditions")
|
|
NodeEquality(t, n1.(*ConditionalNode).condition, n2.(*ConditionalNode).condition)
|
|
t.Log("Checking equality of do statement(s)")
|
|
NodeEquality(t, n1.(*ConditionalNode).do, n2.(*ConditionalNode).do)
|
|
t.Log("Checking equality of else statement(s)")
|
|
NodeEquality(t, n1.(*ConditionalNode).otherwise, n2.(*ConditionalNode).otherwise)
|
|
|
|
case LoopNodeType:
|
|
t.Log("Checking equality of loop conditions")
|
|
NodeEquality(t, n1.(*LoopNode).condition, n2.(*LoopNode).condition)
|
|
t.Log("Checking equality of do loop statement(s)")
|
|
NodeEquality(t, n1.(*LoopNode).do, n2.(*LoopNode).do)
|
|
|
|
case AssignNodeType:
|
|
t.Logf("Checking if value destination matches")
|
|
NodeEquality(t, n1.(*AssignNode).dest, n2.(*AssignNode).dest)
|
|
|
|
if n1.(*AssignNode).declare != n2.(*AssignNode).declare {
|
|
t.Errorf("Not same type of assigning (1: %v; 2: %v)", n1.(*AssignNode).declare, n2.(*AssignNode).declare)
|
|
}
|
|
|
|
t.Logf("Checking equality of assignment values")
|
|
NodeEquality(t, n1.(*AssignNode).value, n2.(*AssignNode).value)
|
|
|
|
case InvokeNodeType:
|
|
n := n1.(*InvokeNode)
|
|
m := n2.(*InvokeNode)
|
|
|
|
NodeEquality(t, n.source, m.source)
|
|
|
|
if len(n.args) != len(m.args) {
|
|
t.Fatalf("Call node arguments count does not match (%d and %d)", len(n.args), m.args)
|
|
}
|
|
|
|
for i, arg := range m.args {
|
|
NodeEquality(t, n1.(*InvokeNode).args[i], arg)
|
|
}
|
|
|
|
case FunctionNodeType:
|
|
n := n1.(*FunctionNode)
|
|
m := n2.(*FunctionNode)
|
|
|
|
if n.name != m.name {
|
|
t.Errorf("Function node names don't match (%s and %s)", n.name, m.name)
|
|
} else {
|
|
t.Logf("Function node names match (%s)", n.name)
|
|
}
|
|
|
|
if len(n.parameters) != len(m.parameters) {
|
|
t.Fatalf("Function node parameters count does not match (%d and %d)", len(n.parameters), len(m.parameters))
|
|
} else {
|
|
t.Logf("Function node parameters count is equal (%d) ", len(n.parameters))
|
|
}
|
|
|
|
for i, p := range m.parameters {
|
|
if !n.parameters[i].Signature.Contains(p.Signature) {
|
|
t.Errorf("Function node parameter signature %d does not match: %s and %s", i, p.Signature, n.parameters[i].Signature)
|
|
} else if n.parameters[i].Name != p.Name {
|
|
t.Errorf("Function node parameter name %d does not match: %s and %s", i, p.Name, n.parameters[i].Name)
|
|
} else {
|
|
t.Logf("Function node parameter %d matches (%s)", i, p)
|
|
}
|
|
}
|
|
|
|
NodeEquality(t, n.logic, m.logic)
|
|
|
|
case ReturnNodeType:
|
|
NodeEquality(t, n1.(*ReturnNode).value, n2.(*ReturnNode).value)
|
|
|
|
case AccessNodeType:
|
|
a1 := n1.(*AccessNode)
|
|
a2 := n2.(*AccessNode)
|
|
|
|
// only care about lexeme; the rest is debug info
|
|
if a1.property.Lexeme != a2.property.Lexeme {
|
|
t.Errorf("Access node property does not match: .%s != .%s", a1.property.Lexeme, a2.property.Lexeme)
|
|
} else {
|
|
t.Logf("Access node property matches: .%s", a1.property.Lexeme)
|
|
}
|
|
|
|
NodeEquality(t, a1.source, a2.source)
|
|
|
|
case ListNodeType:
|
|
l1 := n1.(*ListNode)
|
|
l2 := n2.(*ListNode)
|
|
|
|
if l1.content == nil && l2.content == nil {
|
|
// fine
|
|
t.Logf("Both content types are yet to be determined")
|
|
} else if l1.content != nil || l2.content != nil {
|
|
t.Errorf("one is nil, one is not")
|
|
} else if !l1.content.Contains(l2.content) {
|
|
t.Errorf("signature doesn't match")
|
|
}
|
|
|
|
for i, v1 := range l1.items {
|
|
t.Logf("Checking item %d", i)
|
|
NodeEquality(t, v1, l2.items[i])
|
|
}
|
|
|
|
case TupleNodeType:
|
|
t1 := n1.(*TupleNode)
|
|
t2 := n2.(*TupleNode)
|
|
|
|
if len(t1.items) != len(t2.items) {
|
|
t.Fatalf("tuple item count does not match")
|
|
}
|
|
|
|
for i, v1 := range t1.items {
|
|
t.Logf("Checking item %d", i)
|
|
NodeEquality(t, v1, t2.items[i])
|
|
}
|
|
|
|
default:
|
|
panic("unimplemented node equality")
|
|
}
|
|
}
|
|
|
|
func TestParser_Parse(t *testing.T) {
|
|
t.Logf("Getting test data")
|
|
tokenData := GetTokenTestData()
|
|
|
|
for name, data := range tokenData {
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Logf("Initializing parser")
|
|
p := NewParser("", []string{}, data.tokens)
|
|
|
|
t.Logf("Parsing main")
|
|
tree, err := p.Parse("")
|
|
|
|
if err != nil {
|
|
t.Fatalf("Unexpected error(s): %s", err.(ParsingError).Format())
|
|
}
|
|
|
|
t.Logf("Checking parsed tree")
|
|
NodeEquality(t, tree.Block, data.tree)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParser_AcceptAll(t *testing.T) {
|
|
p := NewParser("a:", []string{}, []Token{
|
|
NewToken(TokenName, 0, 1, 0, "a"),
|
|
NewToken(TokenColon, 1, 2, 0, "a"),
|
|
})
|
|
|
|
if !p.acceptAll(TokenName, TokenColon) {
|
|
t.Fatalf("tokens were not accepted")
|
|
}
|
|
|
|
t.Logf("tokens were accepted")
|
|
}
|
|
|
|
func TestParser_AcceptAll_TooFew(t *testing.T) {
|
|
p := NewParser("a", []string{}, []Token{
|
|
NewToken(TokenName, 0, 1, 0, "a"),
|
|
})
|
|
|
|
if p.acceptAll(TokenName, TokenColon) {
|
|
t.Fatalf("tokens were incorrectly accepted")
|
|
}
|
|
|
|
t.Logf("tokens were, as expected, not accepted")
|
|
}
|
|
|
|
func BenchmarkParser_Parse(b *testing.B) {
|
|
tokenData := GetTokenTestData()
|
|
|
|
for name, data := range tokenData {
|
|
b.Run(name, func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
p := NewParser("", []string{}, data.tokens)
|
|
|
|
_, _ = p.Parse("")
|
|
}
|
|
})
|
|
}
|
|
}
|