arpio/treerack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
1d956dcc66
treerack/mmlexp_test.go

3032 lines
52 KiB
Go
Raw Normal View History

add recent mml syntax
2018-08-19 19:36:23 +02:00
package treerack
import (
"bytes"
"io"
"os"
"testing"
"time"
)
func TestMMLExp(t *testing.T) {
s, err := openSyntaxFile("examples/mml-exp.treerack")
if err != nil {
t.Error(err)
return
}
t.Run("comment", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "empty",
node: &Node{Name: "mml"},
}, {
title: "single line comment",
text: "// foo bar baz",
nodes: []*Node{{
Name: "line-comment-content",
From: 2,
To: 14,
}},
}, {
title: "multiple line comments",
text: "// foo bar\n// baz qux",
nodes: []*Node{{
Name: "line-comment-content",
From: 2,
To: 10,
}, {
Name: "line-comment-content",
From: 13,
To: 21,
}},
}, {
title: "block comment",
text: "/* foo bar baz */",
nodes: []*Node{{
Name: "block-comment-content",
From: 2,
To: 15,
}},
}, {
title: "block comments",
text: "/* foo bar */\n/* baz qux */",
nodes: []*Node{{
Name: "block-comment-content",
From: 2,
To: 11,
}, {
Name: "block-comment-content",
From: 16,
To: 25,
}},
}, {
title: "mixed comments",
text: "// foo\n/* bar */\n// baz",
nodes: []*Node{{
Name: "line-comment-content",
From: 2,
To: 6,
}, {
Name: "block-comment-content",
From: 9,
To: 14,
}, {
Name: "line-comment-content",
From: 19,
To: 23,
}},
}})
})
t.Run("int", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "int",
text: "42",
nodes: []*Node{{
Name: "int",
To: 2,
}},
}, {
title: "ints",
text: "1; 2; 3",
nodes: []*Node{{
Name: "int",
To: 1,
}, {
Name: "int",
From: 3,
To: 4,
}, {
Name: "int",
From: 6,
To: 7,
}},
}, {
title: "int, octal",
text: "052",
nodes: []*Node{{
Name: "int",
To: 3,
}},
}, {
title: "int, hexa",
text: "0x2a",
nodes: []*Node{{
Name: "int",
To: 4,
}},
}})
})
t.Run("float", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "float, 0.",
text: "0.",
nodes: []*Node{{
Name: "float",
To: 2,
}},
}, {
title: "float, 72.40",
text: "72.40",
nodes: []*Node{{
Name: "float",
To: 5,
}},
}, {
title: "float, 072.40",
text: "072.40",
nodes: []*Node{{
Name: "float",
To: 6,
}},
}, {
title: "float, 2.71828",
text: "2.71828",
nodes: []*Node{{
Name: "float",
To: 7,
}},
}, {
title: "float, 6.67428e-11",
text: "6.67428e-11",
nodes: []*Node{{
Name: "float",
To: 11,
}},
}, {
title: "float, 1E6",
text: "1E6",
nodes: []*Node{{
Name: "float",
To: 3,
}},
}, {
title: "float, .25",
text: ".25",
nodes: []*Node{{
Name: "float",
To: 3,
}},
}, {
title: "float, .12345E+5",
text: ".12345E+5",
nodes: []*Node{{
Name: "float",
To: 9,
}},
}, {
title: "float on a new line",
text: "f()\n.9",
nodes: []*Node{{
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "float",
}},
ignorePosition: true,
}})
})
t.Run("string", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "string, empty",
text: "\"\"",
nodes: []*Node{{
Name: "string",
To: 2,
}},
}, {
title: "string",
text: "\"foo\"",
nodes: []*Node{{
Name: "string",
To: 5,
}},
}, {
title: "string, with new line",
text: "\"foo\nbar\"",
nodes: []*Node{{
Name: "string",
To: 9,
}},
}, {
title: "string, with escaped new line",
text: "\"foo\\nbar\"",
nodes: []*Node{{
Name: "string",
To: 10,
}},
}, {
title: "string, with quotes",
text: "\"foo \\\"bar\\\" baz\"",
nodes: []*Node{{
Name: "string",
To: 17,
}},
}})
})
t.Run("bool", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "bool, true",
text: "true",
nodes: []*Node{{
Name: "true",
To: 4,
}},
}, {
title: "bool, false",
text: "false",
nodes: []*Node{{
Name: "false",
To: 5,
}},
}})
})
t.Run("symbol", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "symbol",
text: "foo",
nodes: []*Node{{
Name: "symbol",
To: 3,
}},
}, {
title: "dynamic-symbol",
text: "symbol(a)",
nodes: []*Node{{
Name: "dynamic-symbol",
To: 9,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}},
}},
}})
})
t.Run("list", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "empty list",
text: "[]",
nodes: []*Node{{
Name: "list",
To: 2,
}},
}, {
title: "list",
text: "[a, b, c]",
nodes: []*Node{{
Name: "list",
To: 9,
Nodes: []*Node{{
Name: "symbol",
From: 1,
To: 2,
}, {
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 7,
To: 8,
}},
}},
}, {
title: "list, new lines",
text: "[ \n a \n b \n c \n ]",
nodes: []*Node{{
Name: "list",
To: 17,
Nodes: []*Node{{
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 8,
To: 9,
}, {
Name: "symbol",
From: 12,
To: 13,
}},
}},
}, {
title: "list, complex",
text: "[a, b, c..., [d, e], [f, [g]]...]",
nodes: []*Node{{
Name: "list",
To: 33,
Nodes: []*Node{{
Name: "symbol",
From: 1,
To: 2,
}, {
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "spread-expression",
From: 7,
To: 11,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}},
}, {
Name: "list",
From: 13,
To: 19,
Nodes: []*Node{{
Name: "symbol",
From: 14,
To: 15,
}, {
Name: "symbol",
From: 17,
To: 18,
}},
}, {
Name: "spread-expression",
From: 21,
To: 32,
Nodes: []*Node{{
Name: "list",
From: 21,
To: 29,
Nodes: []*Node{{
Name: "symbol",
From: 22,
To: 23,
}, {
Name: "list",
From: 25,
To: 28,
Nodes: []*Node{{
Name: "symbol",
From: 26,
To: 27,
}},
}},
}},
}},
}},
}})
})
t.Run("mutable list", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "mutable list",
text: "~[a, b, c]",
nodes: []*Node{{
Name: "mutable-list",
To: 10,
Nodes: []*Node{{
Name: "symbol",
From: 2,
To: 3,
}, {
Name: "symbol",
From: 5,
To: 6,
}, {
Name: "symbol",
From: 8,
To: 9,
}},
}},
}})
})
t.Run("struct", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "empty struct",
text: "{}",
nodes: []*Node{{
Name: "struct",
To: 2,
}},
}, {
title: "struct",
text: "{foo: 1, \"bar\": 2, symbol(baz): 3, [qux]: 4}",
nodes: []*Node{{
Name: "struct",
To: 44,
Nodes: []*Node{{
Name: "entry",
From: 1,
To: 7,
Nodes: []*Node{{
Name: "symbol",
From: 1,
To: 4,
}, {
Name: "int",
From: 6,
To: 7,
}},
}, {
Name: "entry",
From: 9,
To: 17,
Nodes: []*Node{{
Name: "string",
From: 9,
To: 14,
}, {
Name: "int",
From: 16,
To: 17,
}},
}, {
Name: "entry",
From: 19,
To: 33,
Nodes: []*Node{{
Name: "dynamic-symbol",
From: 19,
To: 30,
Nodes: []*Node{{
Name: "symbol",
From: 26,
To: 29,
}},
}, {
Name: "int",
From: 32,
To: 33,
}},
}, {
Name: "entry",
From: 35,
To: 43,
Nodes: []*Node{{
Name: "indexer-symbol",
From: 35,
To: 40,
Nodes: []*Node{{
Name: "symbol",
From: 36,
To: 39,
}},
}, {
Name: "int",
From: 42,
To: 43,
}},
}},
}},
}, {
title: "struct, complex",
text: "{foo: 1, {bar: 2}..., {baz: {}}...}",
nodes: []*Node{{
Name: "struct",
To: 35,
Nodes: []*Node{{
Name: "entry",
From: 1,
To: 7,
Nodes: []*Node{{
Name: "symbol",
From: 1,
To: 4,
}, {
Name: "int",
From: 6,
To: 7,
}},
}, {
Name: "spread-expression",
From: 9,
To: 20,
Nodes: []*Node{{
Name: "struct",
From: 9,
To: 17,
Nodes: []*Node{{
Name: "entry",
From: 10,
To: 16,
Nodes: []*Node{{
Name: "symbol",
From: 10,
To: 13,
}, {
Name: "int",
From: 15,
To: 16,
}},
}},
}},
}, {
Name: "spread-expression",
From: 22,
To: 34,
Nodes: []*Node{{
Name: "struct",
From: 22,
To: 31,
Nodes: []*Node{{
Name: "entry",
From: 23,
To: 30,
Nodes: []*Node{{
Name: "symbol",
From: 23,
To: 26,
}, {
Name: "struct",
From: 28,
To: 30,
}},
}},
}},
}},
}},
}, {
title: "struct with indexer key",
text: "{[a]: b}",
nodes: []*Node{{
Name: "struct",
To: 8,
Nodes: []*Node{{
Name: "entry",
From: 1,
To: 7,
Nodes: []*Node{{
Name: "indexer-symbol",
From: 1,
To: 4,
Nodes: []*Node{{
Name: "symbol",
From: 2,
To: 3,
}},
}, {
Name: "symbol",
From: 6,
To: 7,
}},
}},
}},
}})
})
t.Run("mutable struct", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "mutable struct",
text: "~{foo: 1}",
nodes: []*Node{{
Name: "mutable-struct",
To: 9,
Nodes: []*Node{{
Name: "entry",
From: 2,
To: 8,
Nodes: []*Node{{
Name: "symbol",
From: 2,
To: 5,
}, {
Name: "int",
From: 7,
To: 8,
}},
}},
}},
}})
})
t.Run("channel", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "channel",
text: "<>",
nodes: []*Node{{
Name: "channel",
To: 2,
}},
}, {
title: "buffered channel",
text: "<42>",
nodes: []*Node{{
Name: "channel",
To: 4,
Nodes: []*Node{{
Name: "int",
From: 1,
To: 3,
}},
}},
}})
})
t.Run("boolean expressions", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "and expression",
text: "and(a, b, c)",
nodes: []*Node{{
Name: "function-application",
To: 12,
Nodes: []*Node{{
Name: "symbol",
To: 3,
}, {
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 7,
To: 8,
}, {
Name: "symbol",
From: 10,
To: 11,
}},
}},
}, {
title: "or expression",
text: "or(a, b, c)",
nodes: []*Node{{
Name: "function-application",
To: 11,
Nodes: []*Node{{
Name: "symbol",
To: 2,
}, {
Name: "symbol",
From: 3,
To: 4,
}, {
Name: "symbol",
From: 6,
To: 7,
}, {
Name: "symbol",
From: 9,
To: 10,
}},
}},
}})
})
t.Run("function", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "function",
text: "fn () 42",
nodes: []*Node{{
Name: "function",
To: 8,
Nodes: []*Node{{
Name: "int",
From: 6,
To: 8,
}},
}},
}, {
title: "function, noop",
text: "fn () {;}",
nodes: []*Node{{
Name: "function",
To: 9,
Nodes: []*Node{{
Name: "block",
From: 6,
To: 9,
}},
}},
}, {
title: "function with args",
text: "fn (a, b, c) [a, b, c]",
nodes: []*Node{{
Name: "function",
To: 22,
Nodes: []*Node{{
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 7,
To: 8,
}, {
Name: "symbol",
From: 10,
To: 11,
}, {
Name: "list",
From: 13,
To: 22,
Nodes: []*Node{{
Name: "symbol",
From: 14,
To: 15,
}, {
Name: "symbol",
From: 17,
To: 18,
}, {
Name: "symbol",
From: 20,
To: 21,
}},
}},
}},
}, {
title: "function with args in new lines",
text: "fn ( \n a \n b \n c ) [a, b, c]",
nodes: []*Node{{
Name: "function",
To: 28,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}, {
Name: "symbol",
From: 11,
To: 12,
}, {
Name: "symbol",
From: 15,
To: 16,
}, {
Name: "list",
From: 19,
To: 28,
Nodes: []*Node{{
Name: "symbol",
From: 20,
To: 21,
}, {
Name: "symbol",
From: 23,
To: 24,
}, {
Name: "symbol",
From: 26,
To: 27,
}},
}},
}},
}, {
title: "function with spread arg",
text: "fn (a, b, ...c) [a, b, c]",
nodes: []*Node{{
Name: "function",
To: 25,
Nodes: []*Node{{
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 7,
To: 8,
}, {
Name: "collect-symbol",
From: 10,
To: 14,
Nodes: []*Node{{
Name: "symbol",
From: 13,
To: 14,
}},
}, {
Name: "list",
From: 16,
To: 25,
Nodes: []*Node{{
Name: "symbol",
From: 17,
To: 18,
}, {
Name: "symbol",
From: 20,
To: 21,
}, {
Name: "symbol",
From: 23,
To: 24,
}},
}},
}},
}})
})
t.Run("effect", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "effect",
text: "fn ~ () 42",
nodes: []*Node{{
Name: "effect",
To: 10,
Nodes: []*Node{{
Name: "int",
From: 8,
To: 10,
}},
}},
}})
})
t.Run("indexer", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "indexer",
text: "a[42]",
nodes: []*Node{{
Name: "indexer",
To: 5,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "int",
From: 2,
To: 4,
}},
}},
}, {
title: "range indexer",
text: "a[3:9]",
nodes: []*Node{{
Name: "indexer",
To: 6,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "range-from",
From: 2,
To: 3,
Nodes: []*Node{{
Name: "int",
From: 2,
To: 3,
}},
}, {
Name: "range-to",
From: 4,
To: 5,
Nodes: []*Node{{
Name: "int",
From: 4,
To: 5,
}},
}},
}},
}, {
title: "range indexer, lower unbound",
text: "a[:9]",
nodes: []*Node{{
Name: "indexer",
To: 5,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "range-to",
From: 3,
To: 4,
Nodes: []*Node{{
Name: "int",
From: 3,
To: 4,
}},
}},
}},
}, {
title: "range indexer, upper unbound",
text: "a[3:]",
nodes: []*Node{{
Name: "indexer",
To: 5,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "range-from",
From: 2,
To: 3,
Nodes: []*Node{{
Name: "int",
From: 2,
To: 3,
}},
}},
}},
}, {
title: "indexer, chained",
text: "a[b][c][d]",
nodes: []*Node{{
Name: "indexer",
To: 10,
Nodes: []*Node{{
Name: "indexer",
To: 7,
Nodes: []*Node{{
Name: "indexer",
To: 4,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}},
}, {
Name: "symbol",
From: 5,
To: 6,
}},
}, {
Name: "symbol",
From: 8,
To: 9,
}},
}},
}})
})
t.Run("symbol indexer", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "symbol indexer",
text: "a.b",
nodes: []*Node{{
Name: "indexer",
To: 3,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}},
}},
}, {
title: "symbol indexer, with string",
text: "a.\"b\"",
nodes: []*Node{{
Name: "indexer",
To: 5,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "string",
From: 2,
To: 5,
}},
}},
}, {
title: "symbol indexer, with dynamic symbol",
text: "a.symbol(b)",
nodes: []*Node{{
Name: "indexer",
To: 11,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "dynamic-symbol",
From: 2,
To: 11,
Nodes: []*Node{{
Name: "symbol",
From: 9,
To: 10,
}},
}},
}},
}, {
title: "chained symbol indexer",
text: "a.b.c.d",
nodes: []*Node{{
Name: "indexer",
To: 7,
Nodes: []*Node{{
Name: "indexer",
To: 5,
Nodes: []*Node{{
Name: "indexer",
To: 3,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}},
}, {
Name: "symbol",
From: 4,
To: 5,
}},
}, {
Name: "symbol",
From: 6,
To: 7,
}},
}},
}, {
title: "chained symbol indexer on new line",
text: "a\n.b\n.c",
nodes: []*Node{{
Name: "indexer",
To: 7,
Nodes: []*Node{{
Name: "indexer",
To: 4,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 3,
To: 4,
}},
}, {
Name: "symbol",
From: 6,
To: 7,
}},
}},
}, {
title: "chained symbol indexer on new line after dot",
text: "a.\nb.\nc",
nodes: []*Node{{
Name: "indexer",
To: 7,
Nodes: []*Node{{
Name: "indexer",
To: 4,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 3,
To: 4,
}},
}, {
Name: "symbol",
From: 6,
To: 7,
}},
}},
}})
})
t.Run("function application", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "function application",
text: "f()",
nodes: []*Node{{
Name: "function-application",
To: 3,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}},
}},
}, {
title: "function application, single arg",
text: "f(a)",
nodes: []*Node{{
Name: "function-application",
To: 4,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}},
}},
}, {
title: "function application, multiple args",
text: "f(a, b, c)",
nodes: []*Node{{
Name: "function-application",
To: 10,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}, {
Name: "symbol",
From: 5,
To: 6,
}, {
Name: "symbol",
From: 8,
To: 9,
}},
}},
}, {
title: "function application, multiple args, new line",
text: "f(a\nb\nc\n)",
nodes: []*Node{{
Name: "function-application",
To: 9,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}, {
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 6,
To: 7,
}},
}},
}, {
title: "function application, spread",
text: "f(a, b..., c, d...)",
nodes: []*Node{{
Name: "function-application",
To: 19,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}, {
Name: "spread-expression",
From: 5,
To: 9,
Nodes: []*Node{{
Name: "symbol",
From: 5,
To: 6,
}},
}, {
Name: "symbol",
From: 11,
To: 12,
}, {
Name: "spread-expression",
From: 14,
To: 18,
Nodes: []*Node{{
Name: "symbol",
From: 14,
To: 15,
}},
}},
}},
}, {
title: "chained function application",
text: "f(a)(b)(c)",
nodes: []*Node{{
Name: "function-application",
To: 10,
Nodes: []*Node{{
Name: "function-application",
To: 7,
Nodes: []*Node{{
Name: "function-application",
To: 4,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 2,
To: 3,
}},
}, {
Name: "symbol",
From: 5,
To: 6,
}},
}, {
Name: "symbol",
From: 8,
To: 9,
}},
}},
}, {
title: "embedded function application",
text: "f(g(h(a)))",
nodes: []*Node{{
Name: "function-application",
To: 10,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "function-application",
From: 2,
To: 9,
Nodes: []*Node{{
Name: "symbol",
From: 2,
To: 3,
}, {
Name: "function-application",
From: 4,
To: 8,
Nodes: []*Node{{
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 6,
To: 7,
}},
}},
}},
}},
}})
})
t.Run("if", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "if",
text: "if a { b() }",
nodes: []*Node{{
Name: "if",
To: 12,
Nodes: []*Node{{
Name: "symbol",
From: 3,
To: 4,
}, {
Name: "block",
From: 5,
To: 12,
Nodes: []*Node{{
Name: "function-application",
From: 7,
To: 10,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}},
}},
}},
}},
}, {
title: "if, else",
text: "if a { b } else { c }",
nodes: []*Node{{
Name: "if",
To: 21,
Nodes: []*Node{{
Name: "symbol",
From: 3,
To: 4,
}, {
Name: "block",
From: 5,
To: 10,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}},
}, {
Name: "block",
From: 16,
To: 21,
Nodes: []*Node{{
Name: "symbol",
From: 18,
To: 19,
}},
}},
}},
}, {
title: "if, else if, else if, else",
text: "if a { b }\nelse if c { d }\nelse if e { f }\nelse { g }",
nodes: []*Node{{
Name: "if",
From: 0,
To: 53,
Nodes: []*Node{{
Name: "symbol",
From: 3,
To: 4,
}, {
Name: "block",
From: 5,
To: 10,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}},
}, {
Name: "symbol",
From: 19,
To: 20,
}, {
Name: "block",
From: 21,
To: 26,
Nodes: []*Node{{
Name: "symbol",
From: 23,
To: 24,
}},
}, {
Name: "symbol",
From: 35,
To: 36,
}, {
Name: "block",
From: 37,
To: 42,
Nodes: []*Node{{
Name: "symbol",
From: 39,
To: 40,
}},
}, {
Name: "block",
From: 48,
To: 53,
Nodes: []*Node{{
Name: "symbol",
From: 50,
To: 51,
}},
}},
}},
}})
})
t.Run("switch", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "switch, empty",
text: "switch {default:}",
nodes: []*Node{{
Name: "switch",
To: 17,
Nodes: []*Node{{
Name: "default",
From: 8,
To: 16,
}},
}},
}, {
title: "switch, empty cases",
text: `
switch {
case a:
case b:
default:
f()
}
`,
nodes: []*Node{{
Name: "switch",
Nodes: []*Node{{
Name: "case",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "case",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "default",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "switch, single case",
text: "switch a {case b: c}",
nodes: []*Node{{
Name: "switch",
To: 20,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}, {
Name: "case",
From: 10,
To: 17,
Nodes: []*Node{{
Name: "symbol",
From: 15,
To: 16,
}},
}, {
Name: "symbol",
From: 18,
To: 19,
}},
}},
}, {
title: "switch",
text: "switch a {case b: c; case d: e; default: f}",
nodes: []*Node{{
Name: "switch",
To: 43,
Nodes: []*Node{{
Name: "symbol",
From: 7,
To: 8,
}, {
Name: "case",
From: 10,
To: 17,
Nodes: []*Node{{
Name: "symbol",
From: 15,
To: 16,
}},
}, {
Name: "symbol",
From: 18,
To: 19,
}, {
Name: "case",
From: 21,
To: 28,
Nodes: []*Node{{
Name: "symbol",
From: 26,
To: 27,
}},
}, {
Name: "symbol",
From: 29,
To: 30,
}, {
Name: "default",
From: 32,
To: 40,
}, {
Name: "symbol",
From: 41,
To: 42,
}},
}},
}, {
title: "switch, all new lines",
text: "switch \n a \n { \n case \n b \n : \n c \n case \n d \n : \n e \n default \n : \n f \n }",
nodes: []*Node{{
Name: "switch",
To: 74,
Nodes: []*Node{{
Name: "symbol",
From: 9,
To: 10,
}, {
Name: "case",
From: 17,
To: 29,
Nodes: []*Node{{
Name: "symbol",
From: 24,
To: 25,
}},
}, {
Name: "symbol",
From: 32,
To: 33,
}, {
Name: "case",
From: 36,
To: 48,
Nodes: []*Node{{
Name: "symbol",
From: 43,
To: 44,
}},
}, {
Name: "symbol",
From: 51,
To: 52,
}, {
Name: "default",
From: 55,
To: 66,
}, {
Name: "symbol",
From: 69,
To: 70,
}},
}},
}})
})
t.Run("match", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "match expression, empty",
text: "match a {}",
nodes: []*Node{{
Name: "match",
To: 10,
Nodes: []*Node{{
Name: "symbol",
From: 6,
To: 7,
}},
}},
}, {
title: "match expression",
text: "match a {\ncase [first, ...rest]: first\n}",
nodes: []*Node{{
Name: "match",
To: 40,
Nodes: []*Node{{
Name: "symbol",
From: 6,
To: 7,
}, {
Name: "match-case",
From: 10,
To: 32,
Nodes: []*Node{{
Name: "list-type",
From: 15,
To: 31,
Nodes: []*Node{{
Name: "list-destructure-type",
From: 16,
To: 30,
Nodes: []*Node{{
Name: "destructure-item",
From: 16,
To: 21,
Nodes: []*Node{{
Name: "symbol",
From: 16,
To: 21,
}},
}, {
Name: "collect-destructure-item",
From: 23,
To: 30,
Nodes: []*Node{{
Name: "destructure-item",
From: 26,
To: 30,
Nodes: []*Node{{
Name: "symbol",
From: 26,
To: 30,
}},
}},
}},
}},
}},
}, {
Name: "symbol",
From: 33,
To: 38,
}},
}},
}, {
title: "match expression, multiple cases",
text: `match a {
case [0]: []
case [2:]: a[2:]
default: error("invalid length")
}`,
nodes: []*Node{{
Name: "match",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "match-case",
Nodes: []*Node{{
Name: "list-type",
Nodes: []*Node{{
Name: "items-type",
Nodes: []*Node{{
Name: "items-quantifier",
Nodes: []*Node{{
Name: "int",
}},
}},
}},
}},
}, {
Name: "list",
}, {
Name: "match-case",
Nodes: []*Node{{
Name: "list-type",
Nodes: []*Node{{
Name: "items-type",
Nodes: []*Node{{
Name: "items-quantifier",
Nodes: []*Node{{
Name: "static-range-from",
Nodes: []*Node{{
Name: "int",
}},
}},
}},
}},
}},
}, {
Name: "indexer",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "range-from",
Nodes: []*Node{{
Name: "int",
}},
}},
}, {
Name: "default",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "string",
}},
}},
}},
ignorePosition: true,
}, {
title: "match function",
text: `match a {
case fn () int: a()
default: 42
}`,
nodes: []*Node{{
Name: "match",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "match-case",
Nodes: []*Node{{
Name: "function-type",
Nodes: []*Node{{
Name: "int-type",
}},
}},
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "default",
}, {
Name: "int",
}},
}},
ignorePosition: true,
}, {
title: "match expression, combined",
text: `match a {
case [fn (int)]: a[0]()
default: 42
}`,
nodes: []*Node{{
Name: "match",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "match-case",
Nodes: []*Node{{
Name: "list-type",
Nodes: []*Node{{
Name: "items-type",
Nodes: []*Node{{
Name: "function-type",
Nodes: []*Node{{
Name: "arg-type",
Nodes: []*Node{{
Name: "int-type",
}},
}},
}},
}},
}},
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "indexer",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "int",
}},
}},
}, {
Name: "default",
}, {
Name: "int",
}},
}},
ignorePosition: true,
}, {
title: "match expression, complex",
text: `match a {
case [first T int|string, op fn ([T, int, ...T]) int, ...rest T]:
op([first, now(), rest...])
default:
error("invalid list")
}`,
nodes: []*Node{{
Name: "match",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "match-case",
Nodes: []*Node{{
Name: "list-match",
Nodes: []*Node{{
Name: "list-destructure-match",
Nodes: []*Node{{
Name: "destructure-match-item",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}, {
Name: "int-type",
}, {
Name: "string-type",
}},
}, {
Name: "destructure-match-item",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "function-type",
Nodes: []*Node{{
Name: "arg-type",
Nodes: []*Node{{
Name: "list-type",
Nodes: []*Node{{
Name: "list-destructure-type",
Nodes: []*Node{{
Name: "destructure-item",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "destructure-item",
Nodes: []*Node{{
Name: "int-type",
}},
}, {
Name: "collect-destructure-item",
Nodes: []*Node{{
Name: "destructure-item",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}},
}},
}, {
Name: "int-type",
}},
}},
}, {
Name: "collect-destructure-match-item",
Nodes: []*Node{{
Name: "destructure-match-item",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
}},
}},
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "list",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "spread-expression",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}, {
Name: "default",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "string",
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("send/receive", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "receive op",
text: "<-chan",
nodes: []*Node{{
Name: "unary-expression",
Nodes: []*Node{{
Name: "receive-op",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "send op",
text: "chan <- a",
nodes: []*Node{{
Name: "send",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
ignorePosition: true,
}})
})
t.Run("select", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "select, empty",
text: "select {\n}",
nodes: []*Node{{
Name: "select",
To: 10,
}},
}, {
title: "select",
text: `select {
case let a <-r: s <- a
case s <- f(): g()
default: h()
}`,
nodes: []*Node{{
Name: "select",
Nodes: []*Node{{
Name: "select-case",
Nodes: []*Node{{
Name: "receive-definition",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "receive-op",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}, {
Name: "send",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "select-case",
Nodes: []*Node{{
Name: "send",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "default",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "select, call",
text: `select {
case let a receive(r): f()
case send(s, g()): h()
default: i()
}`,
nodes: []*Node{{
Name: "select",
Nodes: []*Node{{
Name: "select-case",
Nodes: []*Node{{
Name: "receive-definition",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "receive-call",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "select-case",
Nodes: []*Node{{
Name: "send",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "default",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("block", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "block",
ignorePosition: true,
text: "{ f() }",
nodes: []*Node{{
Name: "block",
Nodes: []*Node{{
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}})
})
t.Run("go", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "go",
text: "go f()",
nodes: []*Node{{
Name: "go",
Nodes: []*Node{{
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "go, block",
text: "go { for { f() } }",
nodes: []*Node{{
Name: "go",
Nodes: []*Node{{
Name: "block",
Nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "block",
Nodes: []*Node{{
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("require", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "require, dot, equal",
text: "require . = \"mml/foo\"",
nodes: []*Node{{
Name: "require",
Nodes: []*Node{{
Name: "require-fact",
Nodes: []*Node{{
Name: "require-inline",
}, {
Name: "string",
}},
}},
}},
ignorePosition: true,
}, {
title: "require, symbol, equal",
text: "require bar = \"mml/foo\"",
nodes: []*Node{{
Name: "require",
Nodes: []*Node{{
Name: "require-fact",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "string",
}},
}},
}},
ignorePosition: true,
}, {
title: "require, symbol",
text: "require bar \"mml/foo\"",
nodes: []*Node{{
Name: "require",
Nodes: []*Node{{
Name: "require-fact",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "string",
}},
}},
}},
ignorePosition: true,
}, {
title: "require",
text: "require \"mml/foo\"",
nodes: []*Node{{
Name: "require",
Nodes: []*Node{{
Name: "require-fact",
Nodes: []*Node{{
Name: "string",
}},
}},
}},
ignorePosition: true,
}, {
title: "require, group",
text: `require (
. = "mml/foo"
bar = "mml/foo"
. "mml/foo"
bar "mml/foo"
"mml/foo"
)`,
nodes: []*Node{{
Name: "require",
Nodes: []*Node{{
Name: "require-fact",
Nodes: []*Node{{
Name: "require-inline",
}, {
Name: "string",
}},
}, {
Name: "require-fact",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "string",
}},
}, {
Name: "require-fact",
Nodes: []*Node{{
Name: "require-inline",
}, {
Name: "string",
}},
}, {
Name: "require-fact",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "string",
}},
}, {
Name: "require-fact",
Nodes: []*Node{{
Name: "string",
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("expression group", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "expression group",
text: "(fn (a) a)(a)",
nodes: []*Node{{
Name: "function-application",
Nodes: []*Node{{
Name: "function",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "symbol",
}},
}},
ignorePosition: true,
}})
})
t.Run("unary", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "unary operator",
text: "!foo",
nodes: []*Node{{
Name: "unary-expression",
Nodes: []*Node{{
Name: "logical-not",
}, {
Name: "symbol",
}},
}},
ignorePosition: true,
}})
})
t.Run("binary", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "binary 0",
text: "a * b",
nodes: []*Node{{
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}},
ignorePosition: true,
}, {
title: "binary 1",
text: "a * b + c * d",
nodes: []*Node{{
Name: "binary1",
Nodes: []*Node{{
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}, {
Name: "add",
}, {
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "binary 2",
text: "a * b + c * d == e * f",
nodes: []*Node{{
Name: "binary2",
Nodes: []*Node{{
Name: "binary1",
Nodes: []*Node{{
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}, {
Name: "add",
}, {
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}},
}, {
Name: "eq",
}, {
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "binary 1, 1, 1",
text: "a + b + c",
nodes: []*Node{{
Name: "binary1",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "add",
}, {
Name: "symbol",
}, {
Name: "add",
}, {
Name: "symbol",
}},
}},
ignorePosition: true,
}, {
title: "binary 3, 4, 5",
text: "a * b + c * d == e * f && g || h -> f()",
nodes: []*Node{{
Name: "binary5",
Nodes: []*Node{{
Name: "binary4",
Nodes: []*Node{{
Name: "binary3",
Nodes: []*Node{{
Name: "binary2",
Nodes: []*Node{{
Name: "binary1",
Nodes: []*Node{{
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}, {
Name: "add",
}, {
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}},
}, {
Name: "eq",
}, {
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mul",
}, {
Name: "symbol",
}},
}},
}, {
Name: "logical-and",
}, {
Name: "symbol",
}},
}, {
Name: "logical-or",
}, {
Name: "symbol",
}},
}, {
Name: "chain",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("ternary", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "ternary expression",
text: "a ? b : c",
nodes: []*Node{{
Name: "ternary-expression",
To: 9,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 8,
To: 9,
}},
}},
}, {
title: "multiple ternary expressions, consequence",
text: "a ? b ? c : d : e",
nodes: []*Node{{
Name: "ternary-expression",
To: 17,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "ternary-expression",
From: 4,
To: 13,
Nodes: []*Node{{
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "symbol",
From: 8,
To: 9,
}, {
Name: "symbol",
From: 12,
To: 13,
}},
}, {
Name: "symbol",
From: 16,
To: 17,
}},
}},
}, {
title: "multiple ternary expressions, alternative",
text: "a ? b : c ? d : e",
nodes: []*Node{{
Name: "ternary-expression",
To: 17,
Nodes: []*Node{{
Name: "symbol",
To: 1,
}, {
Name: "symbol",
From: 4,
To: 5,
}, {
Name: "ternary-expression",
From: 8,
To: 17,
Nodes: []*Node{{
Name: "symbol",
From: 8,
To: 9,
}, {
Name: "symbol",
From: 12,
To: 13,
}, {
Name: "symbol",
From: 16,
To: 17,
}},
}},
}},
}})
})
t.Run("loop", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "infinite loop",
text: "for {}",
nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "block",
}},
}},
ignorePosition: true,
}, {
title: "conditional loop",
text: "for foo {}",
nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "loop-expression",
Nodes: []*Node{{
Name: "symbol",
}},
}, {
Name: "block",
}},
}},
ignorePosition: true,
}, {
title: "in list loop",
text: "for i in [1, 2, 3] {}",
nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "loop-expression",
Nodes: []*Node{{
Name: "in-expression",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "list",
Nodes: []*Node{{
Name: "int",
}, {
Name: "int",
}, {
Name: "int",
}},
}},
}},
}, {
Name: "block",
}},
}},
ignorePosition: true,
}, {
title: "in range loop",
text: "for i in -3:42 {}",
nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "loop-expression",
Nodes: []*Node{{
Name: "in-expression",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "range-from",
Nodes: []*Node{{
Name: "unary-expression",
Nodes: []*Node{{
Name: "minus",
}, {
Name: "int",
}},
}},
}, {
Name: "range-to",
Nodes: []*Node{{
Name: "int",
}},
}},
}},
}, {
Name: "block",
}},
}},
ignorePosition: true,
}, {
title: "loop control",
text: `for i in l {
if i % 2 == 0 {
break
}
}`,
nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "loop-expression",
Nodes: []*Node{{
Name: "in-expression",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}, {
Name: "block",
Nodes: []*Node{{
Name: "if",
Nodes: []*Node{{
Name: "binary2",
Nodes: []*Node{{
Name: "binary0",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "mod",
}, {
Name: "int",
}},
}, {
Name: "eq",
}, {
Name: "int",
}},
}, {
Name: "block",
Nodes: []*Node{{
Name: "break",
}},
}},
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("assign", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "assign, eq",
text: "a = b",
nodes: []*Node{{
Name: "assignment",
Nodes: []*Node{{
Name: "assign-equal",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "assign, set, eq",
text: "set a = b",
nodes: []*Node{{
Name: "assignment",
Nodes: []*Node{{
Name: "assign-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "assign, set",
text: "set a b",
nodes: []*Node{{
Name: "assignment",
Nodes: []*Node{{
Name: "assign-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "assign, group",
text: `set (
fix/ignore-pending-builders
2018-08-19 22:40:01 +02:00
a = b
c d
)`,
add recent mml syntax
2018-08-19 19:36:23 +02:00
nodes: []*Node{{
Name: "assignment",
Nodes: []*Node{{
Name: "assign-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "assign-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("define", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "define, eq",
text: "let a = b",
nodes: []*Node{{
Name: "value-definition",
Nodes: []*Node{{
Name: "value-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define",
text: "let a b",
nodes: []*Node{{
Name: "value-definition",
Nodes: []*Node{{
Name: "value-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define mutable, eq",
text: "let ~ a = b",
nodes: []*Node{{
Name: "value-definition",
Nodes: []*Node{{
Name: "mutable-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define mutable",
text: "let ~ a b",
nodes: []*Node{{
Name: "value-definition",
Nodes: []*Node{{
Name: "mutable-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "mixed define group",
text: `let (
a = b
c d
~ e f
~ g h
)`,
nodes: []*Node{{
Name: "value-definition-group",
Nodes: []*Node{{
Name: "value-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "value-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "mutable-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "mutable-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "mutable define group",
text: `let ~ (
a = b
c d
)`,
nodes: []*Node{{
Name: "mutable-definition-group",
Nodes: []*Node{{
Name: "value-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "value-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define function",
text: "fn a() b",
nodes: []*Node{{
Name: "function-definition",
Nodes: []*Node{{
Name: "function-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define effect",
text: "fn ~ a() b",
nodes: []*Node{{
Name: "function-definition",
Nodes: []*Node{{
Name: "effect-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define function group",
text: `fn (
a() b
~ c() d
)`,
nodes: []*Node{{
Name: "function-definition-group",
Nodes: []*Node{{
Name: "function-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "effect-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}, {
title: "define effect group",
text: `fn ~ (
a() b
c() d
)`,
nodes: []*Node{{
Name: "effect-definition-group",
Nodes: []*Node{{
Name: "function-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}, {
Name: "function-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
ignorePosition: true,
}})
})
t.Run("type", func(t *testing.T) {
runTestsSyntax(t, s, []testItem{{
title: "type constraint",
text: `
type a fn ([]) int
fn a(l) len(l)
`,
nodes: []*Node{{
Name: "type-constraint",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "function-type",
Nodes: []*Node{{
Name: "arg-type",
Nodes: []*Node{{
Name: "list-type",
}},
}, {
Name: "int-type",
}},
}},
}, {
Name: "function-definition",
Nodes: []*Node{{
Name: "function-capture",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}, {
Name: "function-application",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "symbol",
}},
}},
}},
}},
ignorePosition: true,
}, {
title: "type alias",
text: "type alias a int|(fn () int|string)|string",
nodes: []*Node{{
Name: "type-alias",
Nodes: []*Node{{
Name: "symbol",
}, {
Name: "int-type",
}, {
Name: "function-type",
Nodes: []*Node{{
Name: "int-type",
}, {
Name: "string-type",
}},
}, {
Name: "string-type",
}},
}},
ignorePosition: true,
}, {
title: "statement group",
text: "(for {})",
nodes: []*Node{{
Name: "loop",
Nodes: []*Node{{
Name: "block",
}},
}},
ignorePosition: true,
}})
})
}
func TestMMLFile(t *testing.T) {
if testing.Short() {
t.Skip()
}
const n = 180
fix experimental mml file test
2018-08-19 19:37:27 +02:00
s, err := openSyntaxFile("examples/mml-exp.treerack")
add recent mml syntax
2018-08-19 19:36:23 +02:00
if err != nil {
t.Error(err)
return
}
s.Init()
f, err := os.Open("examples/test.mml")
if err != nil {
t.Error(err)
return
}
defer f.Close()
var d time.Duration
for i := 0; i < n && !t.Failed(); i++ {
func() {
if _, err := f.Seek(0, 0); err != nil {
t.Error(err)
return
}
b := bytes.NewBuffer(nil)
if _, err := io.Copy(b, f); err != nil {
t.Error(err)
return
}
start := time.Now()
_, err = s.Parse(b)
d += time.Now().Sub(start)
if err != nil {
t.Error(err)
}
}()
}
t.Log("average duration:", d/n)
}
Reference in New Issue Copy Permalink