grammar.spec.ts.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`grammar should fail abstract-const-without-modifier 1`] = `
"Syntax error: <unknown>:2:5: Abstract constant doesn't have abstract modifier
Line 2, col 5:
  1 | trait t {
> 2 |     const c: Int;
          ^~~~~~~~~~~~~
  3 | }
"
`;

exports[`grammar should fail const-abstract-abstract 1`] = `
"Syntax error: <unknown>:4:10: Duplicate constant attribute "abstract"
Line 4, col 10:
  3 | 
> 4 | abstract abstract const Foo: Int = 42;
               ^~~~~~~~
  5 | 
"
`;

exports[`grammar should fail const-override 1`] = `
"Syntax error: <unknown>:4:1: Module-level constants do not support attributes
Line 4, col 1:
  3 | 
> 4 | override const Foo: Int = 42;
      ^~~~~~~~
  5 | 
"
`;

exports[`grammar should fail const-override-override 1`] = `
"Syntax error: <unknown>:4:10: Duplicate constant attribute "override"
Line 4, col 10:
  3 | 
> 4 | override override const Foo: Int = 42;
               ^~~~~~~~
  5 | 
"
`;

exports[`grammar should fail const-override-virtual 1`] = `
"Syntax error: <unknown>:4:1: Module-level constants do not support attributes
Line 4, col 1:
  3 | 
> 4 | override virtual const Foo: Int = 42;
      ^~~~~~~~
  5 | 
"
`;

exports[`grammar should fail const-virtual 1`] = `
"Syntax error: <unknown>:4:1: Module-level constants do not support attributes
Line 4, col 1:
  3 | 
> 4 | virtual const Foo: Int = 42;
      ^~~~~~~
  5 | 
"
`;

exports[`grammar should fail const-virtual-override 1`] = `
"Syntax error: <unknown>:4:1: Module-level constants do not support attributes
Line 4, col 1:
  3 | 
> 4 | virtual override const Foo: Int = 42;
      ^~~~~~~
  5 | 
"
`;

exports[`grammar should fail const-virtual-virtual 1`] = `
"Syntax error: <unknown>:4:9: Duplicate constant attribute "virtual"
Line 4, col 9:
  3 | 
> 4 | virtual virtual const Foo: Int = 42;
              ^~~~~~~
  5 | 
"
`;

exports[`grammar should fail contract-const-abstract 1`] = `
"<unknown>:5:26: Parse error: expected "="

Line 5, col 26:
  4 | contract TestContract {
> 5 |   abstract const Foo: Int;
                               ^
  6 | }
"
`;

exports[`grammar should fail contract-const-abstract-abstract 1`] = `
"Syntax error: <unknown>:5:12: Duplicate constant attribute "abstract"
Line 5, col 12:
  4 | contract TestContract {
> 5 |   abstract abstract const Foo: Int = 42;
                 ^~~~~~~~
  6 | }
"
`;

exports[`grammar should fail contract-const-abstract-with-initializer 1`] = `
"Syntax error: <unknown>:5:3: Non-abstract constant has abstract modifier
Line 5, col 3:
  4 | contract TestContract {
> 5 |   abstract const Foo: Int = 42;
        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | }
"
`;

exports[`grammar should fail contract-const-override-override 1`] = `
"Syntax error: <unknown>:5:12: Duplicate constant attribute "override"
Line 5, col 12:
  4 | contract TestContract {
> 5 |   override override const Foo: Int = 42;
                 ^~~~~~~~
  6 | }
"
`;

exports[`grammar should fail contract-const-virtual-virtual 1`] = `
"Syntax error: <unknown>:5:11: Duplicate constant attribute "virtual"
Line 5, col 11:
  4 | contract TestContract {
> 5 |   virtual virtual const Foo: Int = 42;
                ^~~~~~~
  6 | }
"
`;

exports[`grammar should fail contract-empty-traits-list-with-keyword 1`] = `
"<unknown>:1:20: Parse error: expected "_", "A".."Z", or "a".."z"

Line 1, col 20:
> 1 | contract Name with {}
                         ^
  2 | 
"
`;

exports[`grammar should fail contract-getter-parens-no-method-id 1`] = `
"<unknown>:2:9: Parse error: expected "\\"", "initOf", "null", "_", "A".."Z", "a".."z", "false", "true", "0", "1".."9", "0O", "0o", "0B", "0b", "0X", "0x", "(", "~", "!", "+", or "-"

Line 2, col 9:
  1 | contract Test {
> 2 |     get() fun test(): Int {
              ^
  3 |         return 0
"
`;

exports[`grammar should fail contract-init-trailing-comma-empty-params 1`] = `
"Syntax error: <unknown>:2:10: Empty parameter list should not have a dangling comma.
Line 2, col 10:
  1 | contract Name {
> 2 |     init(,) {}
               ^
  3 | }
"
`;

exports[`grammar should fail contract-trailing-comma-empty-traits-list 1`] = `
"<unknown>:1:19: Parse error: expected "_", "A".."Z", or "a".."z"

Line 1, col 19:
> 1 | contract Name with, {}
                        ^
  2 | 
"
`;

exports[`grammar should fail contract-with-imports 1`] = `
"<unknown>:6:1: Parse error: expected end of input, "trait", "contract", "message", "struct", "const", "@name", "asm", "fun", or "primitive"

Line 6, col 1:
  5 | // all imports must be at the very top of the file
> 6 | import "@stdlib/not-allowed";
      ^
  7 | 
"
`;

exports[`grammar should fail destructuring-duplicate-source-id 1`] = `
"Syntax error: <unknown>:15:19: Duplicate destructuring field: 'a'
Line 15, col 19:
  14 |     let s = S{ a: 1, b: 2, c: 3 };
> 15 |     let S { a: x, a: y } = s;
                         ^~~~
  16 |     return x + y;
"
`;

exports[`grammar should fail expr-fun-call-trailing-comma-no-args 1`] = `
"Syntax error: <unknown>:6:14: Empty argument list should not have a dangling comma.
Line 6, col 14:
  5 | fun b(): Int {
> 6 |     return a(,);
                   ^
  7 | }
"
`;

exports[`grammar should fail expr-method-call-trailing-comma-no-args 1`] = `
"Syntax error: <unknown>:2:24: Empty argument list should not have a dangling comma.
Line 2, col 24:
  1 | fun another() {
> 2 |     return 42.toString(,);
                             ^
  3 | }
"
`;

exports[`grammar should fail funcid-native-fun-arith-operator 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(/)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-assign-operator 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(^>>=)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-bitwise-operator 1`] = `
"<unknown>:1:8: Parse error: expected not (a whiteSpace or "(" or ")" or "[" or "]" or "," or "." or ";" or "~") or "\`"

Line 1, col 8:
> 1 | @name(~)
             ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-comma 1`] = `
"<unknown>:1:19: Parse error: expected ")"

Line 1, col 19:
> 1 | @name(send_message,then_terminate)
                        ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-comparison-operator 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(<=>)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-control-keyword 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(elseifnot)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-delimiter 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name([)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-directive 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(#include)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-dot 1`] = `
"<unknown>:1:10: Parse error: expected ")"

Line 1, col 10:
> 1 | @name(msg.sender)
               ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-keyword 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(global)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-multiline-comments 1`] = `
"<unknown>:1:7: Parse error: expected not ("\\"" or "{-")

Line 1, col 7:
> 1 | @name({-aaa-})
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-number 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(123)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-number-decimal 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(0)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-number-hexadecimal 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(0x0)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-number-hexadecimal-2 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(0xDEADBEEF)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-number-neg-decimal 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(-1)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-number-neg-hexadecimal 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(-0x0)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-only-underscore 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(_)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-parens 1`] = `
"<unknown>:1:11: Parse error: expected ")"

Line 1, col 11:
> 1 | @name(take(first)Entry)
                ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-semicolons 1`] = `
"<unknown>:1:9: Parse error: expected ")"

Line 1, col 9:
> 1 | @name(pa;;in"\`aaa\`")
              ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-space 1`] = `
"<unknown>:1:11: Parse error: expected ")"

Line 1, col 11:
> 1 | @name(foo foo)
                ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-square-brackets 1`] = `
"<unknown>:1:11: Parse error: expected ")"

Line 1, col 11:
> 1 | @name(take[some]entry)
                ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-string 1`] = `
"<unknown>:1:7: Parse error: expected not ("\\"" or "{-")

Line 1, col 7:
> 1 | @name("not_a_string)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-type-keyword 1`] = `
"<unknown>:1:7: Parse error: expected not a funcInvalidId or "\`"

Line 1, col 7:
> 1 | @name(->)
            ^
  2 | native idTest();
"
`;

exports[`grammar should fail funcid-native-fun-unclosed-parens 1`] = `
"<unknown>:1:9: Parse error: expected ")"

Line 1, col 9:
> 1 | @name(aa(bb)
              ^
  2 | native idTest();
"
`;

exports[`grammar should fail ident-cannot-be-if-reserved-word 1`] = `
"<unknown>:2:9: Parse error: expected "A".."Z" or not a reservedWord

Line 2, col 9:
  1 | fun hello(): Int {
> 2 |     let if: Int = 0;
              ^
  3 | }
"
`;

exports[`grammar should fail ident-contract-cannot-start-with-__gen 1`] = `
"<unknown>:1:10: Variable name cannot start with "__gen"
Line 1, col 10:
> 1 | contract __gen_a {
               ^~~~~~~
  2 | 
"
`;

exports[`grammar should fail ident-fun-cannot-start-with-__gen 1`] = `
"<unknown>:1:5: Variable name cannot start with "__gen"
Line 1, col 5:
> 1 | fun __gen_hello(): Int {
          ^~~~~~~~~~~
  2 |     
"
`;

exports[`grammar should fail ident-fun-param-cannot-start-with-__gen 1`] = `
"<unknown>:1:10: Variable name cannot start with "__gen"
Line 1, col 10:
> 1 | fun main(__gen: Int): Int {
               ^~~~~
  2 |     return 0;
"
`;

exports[`grammar should fail ident-fun-param-cannot-start-with-__tact 1`] = `
"<unknown>:2:11: Variable name cannot start with "__tact"
Line 2, col 11:
  1 | contract A {
> 2 |     fun b(__tact: Int) {
                ^~~~~~
  3 |         
"
`;

exports[`grammar should fail ident-init-param-cannot-start-with-__tact 1`] = `
"<unknown>:2:10: Variable name cannot start with "__tact"
Line 2, col 10:
  1 | contract A {
> 2 |     init(__tact: Int) {
               ^~~~~~
  3 |         
"
`;

exports[`grammar should fail ident-let-cannot-start-with-__gen 1`] = `
"<unknown>:2:9: Variable name cannot start with "__gen"
Line 2, col 9:
  1 | fun hello(): Int {
> 2 |     let __gen_a: Int = 0;
              ^~~~~~~
  3 | }
"
`;

exports[`grammar should fail ident-let-cannot-start-with-__tact 1`] = `
"<unknown>:2:9: Variable name cannot start with "__tact"
Line 2, col 9:
  1 | fun hello(): Int {
> 2 |     let __tact_a: Int = 0;
              ^~~~~~~~
  3 | }
"
`;

exports[`grammar should fail ident-struct-cannot-start-with-__gen 1`] = `
"<unknown>:1:8: Parse error: expected "A".."Z"

Line 1, col 8:
> 1 | struct __genA {
             ^
  2 |     a: Int;
"
`;

exports[`grammar should fail item-fun-non-void-trailing-comma-no-params 1`] = `
"Syntax error: <unknown>:1:14: Empty parameter list should not have a dangling comma.
Line 1, col 14:
> 1 | fun function(,) : Int {
                   ^
  2 |     return 42;
"
`;

exports[`grammar should fail item-fun-void-trailing-comma-no-params 1`] = `
"Syntax error: <unknown>:1:14: Empty parameter list should not have a dangling comma.
Line 1, col 14:
> 1 | fun function(,) {}
                   ^
  2 | 
"
`;

exports[`grammar should fail item-fun-without-body 1`] = `
"<unknown>:1:20: Parse error: expected "{"

Line 1, col 20:
> 1 | fun testFunc(): Int;
                         ^
"
`;

exports[`grammar should fail item-native-fun-not-void-decl-trailing-comma-no-params 1`] = `
"Syntax error: <unknown>:2:31: Empty parameter list should not have a dangling comma.
Line 2, col 31:
  1 | @name(native_name_2)
> 2 | native testNativeFuncWithType(,): Int;
                                    ^
"
`;

exports[`grammar should fail item-native-fun-void-decl-trailing-comma-no-params 1`] = `
"Syntax error: <unknown>:2:23: Empty parameter list should not have a dangling comma.
Line 2, col 23:
  1 | @name(native_name_1)
> 2 | native testNativeFunc(,);
                            ^
"
`;

exports[`grammar should fail items-asm-fun-1 1`] = `
"<unknown>:1:5: Parse error: expected ")"

Line 1, col 5:
> 1 | asm(1 0) extends fun loadCoins(self: Slice): Int {
          ^
  2 |     LDVARUINT16
"
`;

exports[`grammar should fail items-asm-fun-2 1`] = `
"<unknown>:1:9: Parse error: expected ")", "->", "_", "A".."Z", or "a".."z"

Line 1, col 9:
> 1 | asm(c b 42) extends fun storeDict(b: Builder, c: Cell) {
              ^
  2 |     STDICT
"
`;

exports[`grammar should fail items-asm-fun-3 1`] = `
"<unknown>:1:14: Parse error: expected "0" or "1".."9"

Line 1, col 14:
> 1 | asm(s len -> len 1 0) extends fun loadInt(self: Slice, len: Int): Int {
                   ^
  2 |     LDIX
"
`;

exports[`grammar should fail items-asm-fun-4 1`] = `
"<unknown>:1:7: Parse error: expected "0" or "1".."9"

Line 1, col 7:
> 1 | asm(->) extends fun loadInt(self: Slice, len: Int): Int {
            ^
  2 |     LDIX
"
`;

exports[`grammar should fail items-asm-fun-5 1`] = `
"<unknown>:3:5: Parse error: expected end of input, "trait", "contract", "message", "struct", "const", "@name", "asm", "fun", or "primitive"

Line 3, col 5:
  2 |     { INC } : }
> 3 |     5 }
          ^
  4 | }
"
`;

exports[`grammar should fail items-asm-fun-6 1`] = `
"Syntax error: <unknown>:2:5: The binary bitstring has more than 128 digits
Line 2, col 5:
  1 | asm fun giganticBinary() {
> 2 |     b{000000001111111100000000111111110000000011111111000000001111111100000000111111110000000011111111000000001111111100000000111111110}
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  3 | }
"
`;

exports[`grammar should fail literal-dec-trailing-underscore 1`] = `
"<unknown>:2:16: Parse error: expected a digit

Line 2, col 16:
  1 | fun test_fun(): Int {
> 2 |     return 123_;
                     ^
  3 | }
"
`;

exports[`grammar should fail literal-double-underscore 1`] = `
"<unknown>:2:20: Parse error: expected a digit

Line 2, col 20:
  1 | fun test_fun(): Int {
> 2 |     return 123_123__123;
                         ^
  3 | }
"
`;

exports[`grammar should fail literal-hex-trailing-underscore 1`] = `
"<unknown>:2:18: Parse error: expected a hexadecimal digit

Line 2, col 18:
  1 | fun test_fun(): Int {
> 2 |     return 0x123_;
                       ^
  3 | }
"
`;

exports[`grammar should fail literal-no-underscore-after-0b 1`] = `
"<unknown>:2:14: Parse error: expected "1" or "0"

Line 2, col 14:
  1 | fun test_fun(): Int {
> 2 |     return 0b_00101010;
                   ^
  3 | }
"
`;

exports[`grammar should fail literal-no-underscores-if-leading-zero 1`] = `
"<unknown>:2:15: Parse error: expected "}" or ";"

Line 2, col 15:
  1 | fun test_fun(): Int {
> 2 |     return 012_3;
                    ^
  3 | }
"
`;

exports[`grammar should fail literal-non-binary-digits 1`] = `
"<unknown>:2:15: Parse error: expected "}" or ";"

Line 2, col 15:
  1 | fun test_fun(): Int {
> 2 |     return 0b123;
                    ^
  3 | }
"
`;

exports[`grammar should fail literal-underscore-after-leading-zero 1`] = `
"<unknown>:2:13: Parse error: expected "}" or ";"

Line 2, col 13:
  1 | fun test_fun(): Int {
> 2 |     return 0_123;
                  ^
  3 | }
"
`;

exports[`grammar should fail message-negative-opcode 1`] = `
"<unknown>:1:9: Parse error: expected "0", "1".."9", "0O", "0o", "0B", "0b", "0X", or "0x"

Line 1, col 9:
> 1 | message(-1) Foo { }
              ^
  2 | 
"
`;

exports[`grammar should fail struct-double-semicolon 1`] = `
"<unknown>:2:19: Parse error: expected "}"

Line 2, col 19:
  1 | // too many semicolons
> 2 | struct A { x: Int;; }
                        ^
  3 | 
"
`;

exports[`grammar should fail struct-missing-semicolon-between-fields 1`] = `
"<unknown>:2:19: Parse error: expected "}", ";", "=", "as", or "?"

Line 2, col 19:
  1 | // missing ; between fields
> 2 | struct B { x: Int y: Int }
                        ^
  3 | 
"
`;

exports[`grammar should fail struct-missing-semicolon-between-fields-with-initializer 1`] = `
"<unknown>:2:24: Parse error: expected "}", ";", ".", "!!", "%", "/", "*", ">>", "<<", "-", "+", "==", "!=", "<=", "<", ">=", ">", "^", "&", "&&", "|", "?", or "||"

Line 2, col 24:
  1 | // missing ; between fields
> 2 | struct B { x: Int = 42 y: Int }
                             ^
  3 | 
"
`;

exports[`grammar should fail trait-const-abstract-with-initializer 1`] = `
"Syntax error: <unknown>:5:3: Non-abstract constant has abstract modifier
Line 5, col 3:
  4 | trait TestContract {
> 5 |   abstract const Foo: Int = 42;
        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  6 | }
"
`;

exports[`grammar should fail trait-empty-traits-list-with-keyword 1`] = `
"<unknown>:1:17: Parse error: expected "_", "A".."Z", or "a".."z"

Line 1, col 17:
> 1 | trait Name with {}
                      ^
  2 | 
"
`;

exports[`grammar should fail trait-fun-non-void-trailing-comma-no-params 1`] = `
"Syntax error: <unknown>:2:39: Empty parameter list should not have a dangling comma.
Line 2, col 39:
  1 | trait Test {
> 2 |     abstract fun testAbstractWithType(,): Int;
                                            ^
  3 | }
"
`;

exports[`grammar should fail trait-fun-void-trailing-comma-no-params 1`] = `
"Syntax error: <unknown>:2:31: Empty parameter list should not have a dangling comma.
Line 2, col 31:
  1 | trait Test {
> 2 |     abstract fun testAbstract(,);
                                    ^
  3 | }
"
`;

exports[`grammar should fail trait-trailing-comma-empty-traits-list 1`] = `
"<unknown>:1:16: Parse error: expected "_", "A".."Z", or "a".."z"

Line 1, col 16:
> 1 | trait Name with, {}
                     ^
  2 | 
"
`;

exports[`grammar should fail type-ident-msg-should-be-capitalized 1`] = `
"<unknown>:1:14: Parse error: expected "A".."Z"

Line 1, col 14:
> 1 | message(123) foo {
                   ^
  2 |     signature: Slice;
"
`;

exports[`grammar should fail type-ident-struct-should-be-capitalized 1`] = `
"<unknown>:1:8: Parse error: expected "A".."Z"

Line 1, col 8:
> 1 | struct lowercaseIdForType {
             ^
  2 |     a: Int;
"
`;

exports[`grammar should parse abstract-const 1`] = `
{
  "id": 6,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "attributes": [
            {
              "loc": abstract,
              "type": "abstract",
            },
          ],
          "id": 4,
          "kind": "constant_decl",
          "loc": abstract const c: Int;,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 5,
      "kind": "trait",
      "loc": trait t {
    abstract const c: Int;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": t,
        "text": "t",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse case-35 1`] = `
{
  "id": 7,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "id": 5,
          "kind": "receiver",
          "loc": external() {
        acceptMessage();
    },
          "selector": {
            "kind": "external-fallback",
          },
          "statements": [
            {
              "expression": {
                "args": [],
                "function": {
                  "id": 2,
                  "kind": "id",
                  "loc": acceptMessage,
                  "text": "acceptMessage",
                },
                "id": 3,
                "kind": "static_call",
                "loc": acceptMessage(),
              },
              "id": 4,
              "kind": "statement_expression",
              "loc": acceptMessage();,
            },
          ],
        },
      ],
      "id": 6,
      "kind": "contract",
      "loc": contract ReceiveTestContract {
    external() {
        acceptMessage();
    }
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": ReceiveTestContract,
        "text": "ReceiveTestContract",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-getter-with-method-id 1`] = `
{
  "id": 17,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "attributes": [
            {
              "kind": "function_attribute",
              "loc": get(crc32("crc32") + 42 & 0x3ffff | 0x4000),
              "methodId": {
                "id": 10,
                "kind": "op_binary",
                "left": {
                  "id": 8,
                  "kind": "op_binary",
                  "left": {
                    "id": 6,
                    "kind": "op_binary",
                    "left": {
                      "args": [
                        {
                          "id": 3,
                          "kind": "string",
                          "loc": "crc32",
                          "value": "crc32",
                        },
                      ],
                      "function": {
                        "id": 2,
                        "kind": "id",
                        "loc": crc32,
                        "text": "crc32",
                      },
                      "id": 4,
                      "kind": "static_call",
                      "loc": crc32("crc32"),
                    },
                    "loc": crc32("crc32") + 42,
                    "op": "+",
                    "right": {
                      "base": 10,
                      "id": 5,
                      "kind": "number",
                      "loc": 42,
                      "value": 42n,
                    },
                  },
                  "loc": crc32("crc32") + 42 & 0x3ffff,
                  "op": "&",
                  "right": {
                    "base": 16,
                    "id": 7,
                    "kind": "number",
                    "loc": 0x3ffff,
                    "value": 262143n,
                  },
                },
                "loc": crc32("crc32") + 42 & 0x3ffff | 0x4000,
                "op": "|",
                "right": {
                  "base": 16,
                  "id": 9,
                  "kind": "number",
                  "loc": 0x4000,
                  "value": 16384n,
                },
              },
              "type": "get",
            },
          ],
          "id": 15,
          "kind": "function_def",
          "loc": get(crc32("crc32") + 42 & 0x3ffff | 0x4000) fun test(): Int {
        return 0
    },
          "name": {
            "id": 11,
            "kind": "id",
            "loc": test,
            "text": "test",
          },
          "params": [],
          "return": {
            "id": 12,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
          "statements": [
            {
              "expression": {
                "base": 10,
                "id": 13,
                "kind": "number",
                "loc": 0,
                "value": 0n,
              },
              "id": 14,
              "kind": "statement_return",
              "loc": return 0,
            },
          ],
        },
      ],
      "id": 16,
      "kind": "contract",
      "loc": contract Test {
    get(crc32("crc32") + 42 & 0x3ffff | 0x4000) fun test(): Int {
        return 0
    }
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Test,
        "text": "Test",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-optional-semicolon-for-last-const-def 1`] = `
{
  "id": 7,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "attributes": [],
          "id": 5,
          "initializer": {
            "base": 10,
            "id": 4,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "kind": "constant_def",
          "loc": const foo: Int = 42,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": foo,
            "text": "foo",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 6,
      "kind": "contract",
      "loc": contract Test { const foo: Int = 42 },
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Test,
        "text": "Test",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-optional-semicolon-for-last-storage-var 1`] = `
{
  "id": 8,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 6,
          "initializer": null,
          "kind": "field_decl",
          "loc": m: map<Int, Int>,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": m,
            "text": "m",
          },
          "type": {
            "id": 5,
            "keyStorageType": null,
            "keyType": {
              "id": 3,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
            "kind": "map_type",
            "loc": map<Int, Int>,
            "valueStorageType": null,
            "valueType": {
              "id": 4,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "id": 7,
      "kind": "contract",
      "loc": contract Test { m: map<Int, Int> },
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Test,
        "text": "Test",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-with-const-override 1`] = `
{
  "id": 7,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "attributes": [
            {
              "loc": override,
              "type": "override",
            },
          ],
          "id": 5,
          "initializer": {
            "base": 10,
            "id": 4,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
          "kind": "constant_def",
          "loc": override const Test: Int = 0;,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": Test,
            "text": "Test",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 6,
      "kind": "contract",
      "loc": contract Contract {
    override const Test: Int = 0;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Contract,
        "text": "Contract",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-with-imports 1`] = `
{
  "id": 6,
  "imports": [
    {
      "id": 2,
      "kind": "import",
      "loc": import "@stdlib/deploy";,
      "path": {
        "id": 1,
        "kind": "string",
        "loc": "@stdlib/deploy",
        "value": "@stdlib/deploy",
      },
    },
  ],
  "items": [
    {
      "attributes": [],
      "declarations": [],
      "id": 5,
      "kind": "contract",
      "loc": contract Test with Deploy { },
      "name": {
        "id": 3,
        "kind": "id",
        "loc": Test,
        "text": "Test",
      },
      "traits": [
        {
          "id": 4,
          "kind": "id",
          "loc": Deploy,
          "text": "Deploy",
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-with-init 1`] = `
{
  "id": 26,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 4,
          "initializer": null,
          "kind": "field_decl",
          "loc": a: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 7,
          "initializer": null,
          "kind": "field_decl",
          "loc": b: Int,
          "name": {
            "id": 5,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 6,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 24,
          "kind": "contract_init",
          "loc": init(a: Int, b: Int) {
        self.a = a;
        self.b = b;
    },
          "params": [
            {
              "id": 10,
              "kind": "typed_parameter",
              "loc": a: Int,
              "name": {
                "id": 8,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "type": {
                "id": 9,
                "kind": "type_id",
                "loc": Int,
                "text": "Int",
              },
            },
            {
              "id": 13,
              "kind": "typed_parameter",
              "loc": b: Int,
              "name": {
                "id": 11,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              "type": {
                "id": 12,
                "kind": "type_id",
                "loc": Int,
                "text": "Int",
              },
            },
          ],
          "statements": [
            {
              "expression": {
                "id": 17,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "id": 18,
              "kind": "statement_assign",
              "loc": self.a = a;,
              "path": {
                "aggregate": {
                  "id": 14,
                  "kind": "id",
                  "loc": self,
                  "text": "self",
                },
                "field": {
                  "id": 15,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "id": 16,
                "kind": "field_access",
                "loc": self.a,
              },
            },
            {
              "expression": {
                "id": 22,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              "id": 23,
              "kind": "statement_assign",
              "loc": self.b = b;,
              "path": {
                "aggregate": {
                  "id": 19,
                  "kind": "id",
                  "loc": self,
                  "text": "self",
                },
                "field": {
                  "id": 20,
                  "kind": "id",
                  "loc": b,
                  "text": "b",
                },
                "id": 21,
                "kind": "field_access",
                "loc": self.b,
              },
            },
          ],
        },
      ],
      "id": 25,
      "kind": "contract",
      "loc": contract Sample {
    a: Int;
    b: Int;
    
    init(a: Int, b: Int) {
        self.a = a;
        self.b = b;
    }
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Sample,
        "text": "Sample",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-with-trait 1`] = `
{
  "id": 24,
  "imports": [],
  "items": [
    {
      "id": 2,
      "kind": "primitive_type_decl",
      "loc": primitive Int;,
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 6,
          "initializer": null,
          "kind": "field_decl",
          "loc": a: Int,
          "name": {
            "id": 4,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 5,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "attributes": [
            {
              "kind": "function_attribute",
              "loc": virtual,
              "type": "virtual",
            },
          ],
          "id": 11,
          "kind": "function_def",
          "loc": virtual fun a(): Int {
        return a;
    },
          "name": {
            "id": 7,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "params": [],
          "return": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
          "statements": [
            {
              "expression": {
                "id": 9,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "id": 10,
              "kind": "statement_return",
              "loc": return a;,
            },
          ],
        },
      ],
      "id": 12,
      "kind": "trait",
      "loc": trait SomeTrait {
    a: Int;

    virtual fun a(): Int {
        return a;
    }
},
      "name": {
        "id": 3,
        "kind": "id",
        "loc": SomeTrait,
        "text": "SomeTrait",
      },
      "traits": [],
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 16,
          "initializer": null,
          "kind": "field_decl",
          "loc": b: Int,
          "name": {
            "id": 14,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 15,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "attributes": [
            {
              "kind": "function_attribute",
              "loc": override,
              "type": "override",
            },
          ],
          "id": 21,
          "kind": "function_def",
          "loc": override fun a(): Int {
        return b;
    },
          "name": {
            "id": 17,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "params": [],
          "return": {
            "id": 18,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
          "statements": [
            {
              "expression": {
                "id": 19,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              "id": 20,
              "kind": "statement_return",
              "loc": return b;,
            },
          ],
        },
      ],
      "id": 23,
      "kind": "contract",
      "loc": contract Main with SomeTrait {
    b: Int;

    override fun a(): Int {
        return b;
    }
},
      "name": {
        "id": 13,
        "kind": "id",
        "loc": Main,
        "text": "Main",
      },
      "traits": [
        {
          "id": 22,
          "kind": "id",
          "loc": SomeTrait,
          "text": "SomeTrait",
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse contract-with-trait-string-literal 1`] = `
{
  "id": 24,
  "imports": [],
  "items": [
    {
      "id": 2,
      "kind": "primitive_type_decl",
      "loc": primitive Int;,
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 6,
          "initializer": null,
          "kind": "field_decl",
          "loc": a: Int,
          "name": {
            "id": 4,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 5,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "attributes": [
            {
              "kind": "function_attribute",
              "loc": virtual,
              "type": "virtual",
            },
          ],
          "id": 11,
          "kind": "function_def",
          "loc": virtual fun a(): Int {
        return a;
    },
          "name": {
            "id": 7,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "params": [],
          "return": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
          "statements": [
            {
              "expression": {
                "id": 9,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "id": 10,
              "kind": "statement_return",
              "loc": return a;,
            },
          ],
        },
      ],
      "id": 12,
      "kind": "trait",
      "loc": trait SomeTrait {
    a: Int;

    virtual fun a(): Int {
        return a;
    }
},
      "name": {
        "id": 3,
        "kind": "id",
        "loc": SomeTrait,
        "text": "SomeTrait",
      },
      "traits": [],
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 16,
          "initializer": null,
          "kind": "field_decl",
          "loc": b: Int,
          "name": {
            "id": 14,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 15,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "attributes": [
            {
              "kind": "function_attribute",
              "loc": override,
              "type": "override",
            },
          ],
          "id": 21,
          "kind": "function_def",
          "loc": override fun a(): Int {
        return "hello world!";
    },
          "name": {
            "id": 17,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "params": [],
          "return": {
            "id": 18,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
          "statements": [
            {
              "expression": {
                "id": 19,
                "kind": "string",
                "loc": "hello world!",
                "value": "hello world!",
              },
              "id": 20,
              "kind": "statement_return",
              "loc": return "hello world!";,
            },
          ],
        },
      ],
      "id": 23,
      "kind": "contract",
      "loc": contract Main with SomeTrait {
    b: Int;

    override fun a(): Int {
        return "hello world!";
    }
},
      "name": {
        "id": 13,
        "kind": "id",
        "loc": Main,
        "text": "Main",
      },
      "traits": [
        {
          "id": 22,
          "kind": "id",
          "loc": SomeTrait,
          "text": "SomeTrait",
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-arith 1`] = `
{
  "id": 12,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 11,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return (0 + 1) * 10 / 20;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 9,
            "kind": "op_binary",
            "left": {
              "id": 7,
              "kind": "op_binary",
              "left": {
                "id": 5,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 3,
                  "kind": "number",
                  "loc": 0,
                  "value": 0n,
                },
                "loc": 0 + 1,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 4,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
              },
              "loc": (0 + 1) * 10,
              "op": "*",
              "right": {
                "base": 10,
                "id": 6,
                "kind": "number",
                "loc": 10,
                "value": 10n,
              },
            },
            "loc": (0 + 1) * 10 / 20,
            "op": "/",
            "right": {
              "base": 10,
              "id": 8,
              "kind": "number",
              "loc": 20,
              "value": 20n,
            },
          },
          "id": 10,
          "kind": "statement_return",
          "loc": return (0 + 1) * 10 / 20;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-arith-and-cmp 1`] = `
{
  "id": 14,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 13,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return (0 + 1) * 10 / 20 != 10;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 11,
            "kind": "op_binary",
            "left": {
              "id": 9,
              "kind": "op_binary",
              "left": {
                "id": 7,
                "kind": "op_binary",
                "left": {
                  "id": 5,
                  "kind": "op_binary",
                  "left": {
                    "base": 10,
                    "id": 3,
                    "kind": "number",
                    "loc": 0,
                    "value": 0n,
                  },
                  "loc": 0 + 1,
                  "op": "+",
                  "right": {
                    "base": 10,
                    "id": 4,
                    "kind": "number",
                    "loc": 1,
                    "value": 1n,
                  },
                },
                "loc": (0 + 1) * 10,
                "op": "*",
                "right": {
                  "base": 10,
                  "id": 6,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "loc": (0 + 1) * 10 / 20,
              "op": "/",
              "right": {
                "base": 10,
                "id": 8,
                "kind": "number",
                "loc": 20,
                "value": 20n,
              },
            },
            "loc": (0 + 1) * 10 / 20 != 10,
            "op": "!=",
            "right": {
              "base": 10,
              "id": 10,
              "kind": "number",
              "loc": 10,
              "value": 10n,
            },
          },
          "id": 12,
          "kind": "statement_return",
          "loc": return (0 + 1) * 10 / 20 != 10;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-arith-bool-cmp-method-call 1`] = `
{
  "id": 27,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 26,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < 123.add(10);
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 24,
            "kind": "op_binary",
            "left": {
              "id": 13,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "op_binary",
                "left": {
                  "id": 7,
                  "kind": "op_binary",
                  "left": {
                    "id": 5,
                    "kind": "op_binary",
                    "left": {
                      "base": 10,
                      "id": 3,
                      "kind": "number",
                      "loc": 0,
                      "value": 0n,
                    },
                    "loc": 0 + 1,
                    "op": "+",
                    "right": {
                      "base": 10,
                      "id": 4,
                      "kind": "number",
                      "loc": 1,
                      "value": 1n,
                    },
                  },
                  "loc": (0 + 1) * 10,
                  "op": "*",
                  "right": {
                    "base": 10,
                    "id": 6,
                    "kind": "number",
                    "loc": 10,
                    "value": 10n,
                  },
                },
                "loc": (0 + 1) * 10 / 20,
                "op": "/",
                "right": {
                  "base": 10,
                  "id": 8,
                  "kind": "number",
                  "loc": 20,
                  "value": 20n,
                },
              },
              "loc": (0 + 1) * 10 / 20 != 10 * someId,
              "op": "!=",
              "right": {
                "id": 12,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 10,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
                "loc": 10 * someId,
                "op": "*",
                "right": {
                  "id": 11,
                  "kind": "id",
                  "loc": someId,
                  "text": "someId",
                },
              },
            },
            "loc": (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < 123.add(10),
            "op": "||",
            "right": {
              "id": 23,
              "kind": "op_binary",
              "left": {
                "id": 16,
                "kind": "op_binary",
                "left": {
                  "id": 14,
                  "kind": "id",
                  "loc": some2,
                  "text": "some2",
                },
                "loc": some2 > 10,
                "op": ">",
                "right": {
                  "base": 10,
                  "id": 15,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "loc": some2 > 10 && some3 < 123.add(10),
              "op": "&&",
              "right": {
                "id": 22,
                "kind": "op_binary",
                "left": {
                  "id": 17,
                  "kind": "id",
                  "loc": some3,
                  "text": "some3",
                },
                "loc": some3 < 123.add(10),
                "op": "<",
                "right": {
                  "args": [
                    {
                      "base": 10,
                      "id": 20,
                      "kind": "number",
                      "loc": 10,
                      "value": 10n,
                    },
                  ],
                  "id": 21,
                  "kind": "method_call",
                  "loc": 123.add(10),
                  "method": {
                    "id": 19,
                    "kind": "id",
                    "loc": add,
                    "text": "add",
                  },
                  "self": {
                    "base": 10,
                    "id": 18,
                    "kind": "number",
                    "loc": 123,
                    "value": 123n,
                  },
                },
              },
            },
          },
          "id": 25,
          "kind": "statement_return",
          "loc": return (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < 123.add(10);,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-arith-bool-var 1`] = `
{
  "id": 24,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 23,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < 10;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 21,
            "kind": "op_binary",
            "left": {
              "id": 13,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "op_binary",
                "left": {
                  "id": 7,
                  "kind": "op_binary",
                  "left": {
                    "id": 5,
                    "kind": "op_binary",
                    "left": {
                      "base": 10,
                      "id": 3,
                      "kind": "number",
                      "loc": 0,
                      "value": 0n,
                    },
                    "loc": 0 + 1,
                    "op": "+",
                    "right": {
                      "base": 10,
                      "id": 4,
                      "kind": "number",
                      "loc": 1,
                      "value": 1n,
                    },
                  },
                  "loc": (0 + 1) * 10,
                  "op": "*",
                  "right": {
                    "base": 10,
                    "id": 6,
                    "kind": "number",
                    "loc": 10,
                    "value": 10n,
                  },
                },
                "loc": (0 + 1) * 10 / 20,
                "op": "/",
                "right": {
                  "base": 10,
                  "id": 8,
                  "kind": "number",
                  "loc": 20,
                  "value": 20n,
                },
              },
              "loc": (0 + 1) * 10 / 20 != 10 * someId,
              "op": "!=",
              "right": {
                "id": 12,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 10,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
                "loc": 10 * someId,
                "op": "*",
                "right": {
                  "id": 11,
                  "kind": "id",
                  "loc": someId,
                  "text": "someId",
                },
              },
            },
            "loc": (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < 10,
            "op": "||",
            "right": {
              "id": 20,
              "kind": "op_binary",
              "left": {
                "id": 16,
                "kind": "op_binary",
                "left": {
                  "id": 14,
                  "kind": "id",
                  "loc": some2,
                  "text": "some2",
                },
                "loc": some2 > 10,
                "op": ">",
                "right": {
                  "base": 10,
                  "id": 15,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "loc": some2 > 10 && some3 < 10,
              "op": "&&",
              "right": {
                "id": 19,
                "kind": "op_binary",
                "left": {
                  "id": 17,
                  "kind": "id",
                  "loc": some3,
                  "text": "some3",
                },
                "loc": some3 < 10,
                "op": "<",
                "right": {
                  "base": 10,
                  "id": 18,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
            },
          },
          "id": 22,
          "kind": "statement_return",
          "loc": return (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < 10;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-chaining-unbox 1`] = `
{
  "id": 16,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 15,
      "kind": "function_def",
      "loc": fun testFunc(m: map<Int, Int>): Int {
    return m.asCell()!!.hash();
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 7,
          "kind": "typed_parameter",
          "loc": m: map<Int, Int>,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": m,
            "text": "m",
          },
          "type": {
            "id": 6,
            "keyStorageType": null,
            "keyType": {
              "id": 4,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
            "kind": "map_type",
            "loc": map<Int, Int>,
            "valueStorageType": null,
            "valueType": {
              "id": 5,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "args": [],
            "id": 13,
            "kind": "method_call",
            "loc": m.asCell()!!.hash(),
            "method": {
              "id": 12,
              "kind": "id",
              "loc": hash,
              "text": "hash",
            },
            "self": {
              "id": 11,
              "kind": "op_unary",
              "loc": m.asCell()!!,
              "op": "!!",
              "operand": {
                "args": [],
                "id": 10,
                "kind": "method_call",
                "loc": m.asCell(),
                "method": {
                  "id": 9,
                  "kind": "id",
                  "loc": asCell,
                  "text": "asCell",
                },
                "self": {
                  "id": 8,
                  "kind": "id",
                  "loc": m,
                  "text": "m",
                },
              },
            },
          },
          "id": 14,
          "kind": "statement_return",
          "loc": return m.asCell()!!.hash();,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-condition-with-or 1`] = `
{
  "id": 22,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 21,
      "kind": "function_def",
      "loc": fun testFunc(a: Int): Int {
    return a == 123 || a == 456 ? a + 1 : a + 2;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 5,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "condition": {
              "id": 12,
              "kind": "op_binary",
              "left": {
                "id": 8,
                "kind": "op_binary",
                "left": {
                  "id": 6,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "loc": a == 123,
                "op": "==",
                "right": {
                  "base": 10,
                  "id": 7,
                  "kind": "number",
                  "loc": 123,
                  "value": 123n,
                },
              },
              "loc": a == 123 || a == 456,
              "op": "||",
              "right": {
                "id": 11,
                "kind": "op_binary",
                "left": {
                  "id": 9,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "loc": a == 456,
                "op": "==",
                "right": {
                  "base": 10,
                  "id": 10,
                  "kind": "number",
                  "loc": 456,
                  "value": 456n,
                },
              },
            },
            "elseBranch": {
              "id": 18,
              "kind": "op_binary",
              "left": {
                "id": 16,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a + 2,
              "op": "+",
              "right": {
                "base": 10,
                "id": 17,
                "kind": "number",
                "loc": 2,
                "value": 2n,
              },
            },
            "id": 19,
            "kind": "conditional",
            "loc": a == 123 || a == 456 ? a + 1 : a + 2,
            "thenBranch": {
              "id": 15,
              "kind": "op_binary",
              "left": {
                "id": 13,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a + 1,
              "op": "+",
              "right": {
                "base": 10,
                "id": 14,
                "kind": "number",
                "loc": 1,
                "value": 1n,
              },
            },
          },
          "id": 20,
          "kind": "statement_return",
          "loc": return a == 123 || a == 456 ? a + 1 : a + 2;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-conditional 1`] = `
{
  "id": 14,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 13,
      "kind": "function_def",
      "loc": fun testFunc(a: Int): Int {
    return a == 123 ? 1 : 2;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 5,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "condition": {
              "id": 8,
              "kind": "op_binary",
              "left": {
                "id": 6,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a == 123,
              "op": "==",
              "right": {
                "base": 10,
                "id": 7,
                "kind": "number",
                "loc": 123,
                "value": 123n,
              },
            },
            "elseBranch": {
              "base": 10,
              "id": 10,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
            "id": 11,
            "kind": "conditional",
            "loc": a == 123 ? 1 : 2,
            "thenBranch": {
              "base": 10,
              "id": 9,
              "kind": "number",
              "loc": 1,
              "value": 1n,
            },
          },
          "id": 12,
          "kind": "statement_return",
          "loc": return a == 123 ? 1 : 2;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-conditional-with-let 1`] = `
{
  "id": 18,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 17,
      "kind": "function_def",
      "loc": fun testFunc(a: Int): Int {
    let b: Int = a == 123 ? 1 : 2;
    return b;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 5,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "condition": {
              "id": 10,
              "kind": "op_binary",
              "left": {
                "id": 8,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a == 123,
              "op": "==",
              "right": {
                "base": 10,
                "id": 9,
                "kind": "number",
                "loc": 123,
                "value": 123n,
              },
            },
            "elseBranch": {
              "base": 10,
              "id": 12,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
            "id": 13,
            "kind": "conditional",
            "loc": a == 123 ? 1 : 2,
            "thenBranch": {
              "base": 10,
              "id": 11,
              "kind": "number",
              "loc": 1,
              "value": 1n,
            },
          },
          "id": 14,
          "kind": "statement_let",
          "loc": let b: Int = a == 123 ? 1 : 2;,
          "name": {
            "id": 6,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 7,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 15,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 16,
          "kind": "statement_return",
          "loc": return b;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-fun-call 1`] = `
{
  "id": 29,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 28,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < abs(123.add(10));
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 26,
            "kind": "op_binary",
            "left": {
              "id": 13,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "op_binary",
                "left": {
                  "id": 7,
                  "kind": "op_binary",
                  "left": {
                    "id": 5,
                    "kind": "op_binary",
                    "left": {
                      "base": 10,
                      "id": 3,
                      "kind": "number",
                      "loc": 0,
                      "value": 0n,
                    },
                    "loc": 0 + 1,
                    "op": "+",
                    "right": {
                      "base": 10,
                      "id": 4,
                      "kind": "number",
                      "loc": 1,
                      "value": 1n,
                    },
                  },
                  "loc": (0 + 1) * 10,
                  "op": "*",
                  "right": {
                    "base": 10,
                    "id": 6,
                    "kind": "number",
                    "loc": 10,
                    "value": 10n,
                  },
                },
                "loc": (0 + 1) * 10 / 20,
                "op": "/",
                "right": {
                  "base": 10,
                  "id": 8,
                  "kind": "number",
                  "loc": 20,
                  "value": 20n,
                },
              },
              "loc": (0 + 1) * 10 / 20 != 10 * someId,
              "op": "!=",
              "right": {
                "id": 12,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 10,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
                "loc": 10 * someId,
                "op": "*",
                "right": {
                  "id": 11,
                  "kind": "id",
                  "loc": someId,
                  "text": "someId",
                },
              },
            },
            "loc": (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < abs(123.add(10)),
            "op": "||",
            "right": {
              "id": 25,
              "kind": "op_binary",
              "left": {
                "id": 16,
                "kind": "op_binary",
                "left": {
                  "id": 14,
                  "kind": "id",
                  "loc": some2,
                  "text": "some2",
                },
                "loc": some2 > 10,
                "op": ">",
                "right": {
                  "base": 10,
                  "id": 15,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "loc": some2 > 10 && some3 < abs(123.add(10)),
              "op": "&&",
              "right": {
                "id": 24,
                "kind": "op_binary",
                "left": {
                  "id": 17,
                  "kind": "id",
                  "loc": some3,
                  "text": "some3",
                },
                "loc": some3 < abs(123.add(10)),
                "op": "<",
                "right": {
                  "args": [
                    {
                      "args": [
                        {
                          "base": 10,
                          "id": 21,
                          "kind": "number",
                          "loc": 10,
                          "value": 10n,
                        },
                      ],
                      "id": 22,
                      "kind": "method_call",
                      "loc": 123.add(10),
                      "method": {
                        "id": 20,
                        "kind": "id",
                        "loc": add,
                        "text": "add",
                      },
                      "self": {
                        "base": 10,
                        "id": 19,
                        "kind": "number",
                        "loc": 123,
                        "value": 123n,
                      },
                    },
                  ],
                  "function": {
                    "id": 18,
                    "kind": "id",
                    "loc": abs,
                    "text": "abs",
                  },
                  "id": 23,
                  "kind": "static_call",
                  "loc": abs(123.add(10)),
                },
              },
            },
          },
          "id": 27,
          "kind": "statement_return",
          "loc": return (0 + 1) * 10 / 20 != 10 * someId || some2 > 10 && some3 < abs(123.add(10));,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-int-literal 1`] = `
{
  "id": 6,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 5,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return 0;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 3,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
          "id": 4,
          "kind": "statement_return",
          "loc": return 0;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-nested-conditional 1`] = `
{
  "id": 27,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 26,
      "kind": "function_def",
      "loc": fun testFunc(a: Int): Int {
    return a == 123 || a == 456 ? (a == 10 ? a : a * 2) : a + 2;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 5,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "condition": {
              "id": 12,
              "kind": "op_binary",
              "left": {
                "id": 8,
                "kind": "op_binary",
                "left": {
                  "id": 6,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "loc": a == 123,
                "op": "==",
                "right": {
                  "base": 10,
                  "id": 7,
                  "kind": "number",
                  "loc": 123,
                  "value": 123n,
                },
              },
              "loc": a == 123 || a == 456,
              "op": "||",
              "right": {
                "id": 11,
                "kind": "op_binary",
                "left": {
                  "id": 9,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "loc": a == 456,
                "op": "==",
                "right": {
                  "base": 10,
                  "id": 10,
                  "kind": "number",
                  "loc": 456,
                  "value": 456n,
                },
              },
            },
            "elseBranch": {
              "id": 23,
              "kind": "op_binary",
              "left": {
                "id": 21,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a + 2,
              "op": "+",
              "right": {
                "base": 10,
                "id": 22,
                "kind": "number",
                "loc": 2,
                "value": 2n,
              },
            },
            "id": 24,
            "kind": "conditional",
            "loc": a == 123 || a == 456 ? (a == 10 ? a : a * 2) : a + 2,
            "thenBranch": {
              "condition": {
                "id": 15,
                "kind": "op_binary",
                "left": {
                  "id": 13,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "loc": a == 10,
                "op": "==",
                "right": {
                  "base": 10,
                  "id": 14,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "elseBranch": {
                "id": 19,
                "kind": "op_binary",
                "left": {
                  "id": 17,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "loc": a * 2,
                "op": "*",
                "right": {
                  "base": 10,
                  "id": 18,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
              },
              "id": 20,
              "kind": "conditional",
              "loc": a == 10 ? a : a * 2,
              "thenBranch": {
                "id": 16,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
            },
          },
          "id": 25,
          "kind": "statement_return",
          "loc": return a == 123 || a == 456 ? (a == 10 ? a : a * 2) : a + 2;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-parens 1`] = `
{
  "id": 15,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 14,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return 1 + 2 + (123 + 3)!! > 123;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 12,
            "kind": "op_binary",
            "left": {
              "id": 10,
              "kind": "op_binary",
              "left": {
                "id": 5,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 3,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "loc": 1 + 2,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 4,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
              },
              "loc": 1 + 2 + (123 + 3)!!,
              "op": "+",
              "right": {
                "id": 9,
                "kind": "op_unary",
                "loc": (123 + 3)!!,
                "op": "!!",
                "operand": {
                  "id": 8,
                  "kind": "op_binary",
                  "left": {
                    "base": 10,
                    "id": 6,
                    "kind": "number",
                    "loc": 123,
                    "value": 123n,
                  },
                  "loc": 123 + 3,
                  "op": "+",
                  "right": {
                    "base": 10,
                    "id": 7,
                    "kind": "number",
                    "loc": 3,
                    "value": 3n,
                  },
                },
              },
            },
            "loc": 1 + 2 + (123 + 3)!! > 123,
            "op": ">",
            "right": {
              "base": 10,
              "id": 11,
              "kind": "number",
              "loc": 123,
              "value": 123n,
            },
          },
          "id": 13,
          "kind": "statement_return",
          "loc": return 1 + 2 + (123 + 3)!! > 123;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-with-unbox 1`] = `
{
  "id": 13,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 12,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return 1 + 2 + 3!! > 123;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 10,
            "kind": "op_binary",
            "left": {
              "id": 8,
              "kind": "op_binary",
              "left": {
                "id": 5,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 3,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "loc": 1 + 2,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 4,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
              },
              "loc": 1 + 2 + 3!!,
              "op": "+",
              "right": {
                "id": 7,
                "kind": "op_unary",
                "loc": 3!!,
                "op": "!!",
                "operand": {
                  "base": 10,
                  "id": 6,
                  "kind": "number",
                  "loc": 3,
                  "value": 3n,
                },
              },
            },
            "loc": 1 + 2 + 3!! > 123,
            "op": ">",
            "right": {
              "base": 10,
              "id": 9,
              "kind": "number",
              "loc": 123,
              "value": 123n,
            },
          },
          "id": 11,
          "kind": "statement_return",
          "loc": return 1 + 2 + 3!! > 123;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse expr-with-var 1`] = `
{
  "id": 16,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 15,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return (0 + 1) * 10 / 20 != 10 * someId;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 13,
            "kind": "op_binary",
            "left": {
              "id": 9,
              "kind": "op_binary",
              "left": {
                "id": 7,
                "kind": "op_binary",
                "left": {
                  "id": 5,
                  "kind": "op_binary",
                  "left": {
                    "base": 10,
                    "id": 3,
                    "kind": "number",
                    "loc": 0,
                    "value": 0n,
                  },
                  "loc": 0 + 1,
                  "op": "+",
                  "right": {
                    "base": 10,
                    "id": 4,
                    "kind": "number",
                    "loc": 1,
                    "value": 1n,
                  },
                },
                "loc": (0 + 1) * 10,
                "op": "*",
                "right": {
                  "base": 10,
                  "id": 6,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "loc": (0 + 1) * 10 / 20,
              "op": "/",
              "right": {
                "base": 10,
                "id": 8,
                "kind": "number",
                "loc": 20,
                "value": 20n,
              },
            },
            "loc": (0 + 1) * 10 / 20 != 10 * someId,
            "op": "!=",
            "right": {
              "id": 12,
              "kind": "op_binary",
              "left": {
                "base": 10,
                "id": 10,
                "kind": "number",
                "loc": 10,
                "value": 10n,
              },
              "loc": 10 * someId,
              "op": "*",
              "right": {
                "id": 11,
                "kind": "id",
                "loc": someId,
                "text": "someId",
              },
            },
          },
          "id": 14,
          "kind": "statement_return",
          "loc": return (0 + 1) * 10 / 20 != 10 * someId;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse items-asm-funs 1`] = `
{
  "id": 67,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 6,
      "instructions": [
        "1",
        "INT",
        "HASHEXT_KECCAK256",
      ],
      "kind": "asm_function_def",
      "loc": asm fun keccak256(s: Slice): Int {
    1
    INT
    HASHEXT_KECCAK256
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": keccak256,
        "text": "keccak256",
      },
      "params": [
        {
          "id": 5,
          "kind": "typed_parameter",
          "loc": s: Slice,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Slice,
            "text": "Slice",
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [
        {
          "kind": "function_attribute",
          "loc": extends,
          "type": "extends",
        },
      ],
      "id": 14,
      "instructions": [
        "LDVARUINT16",
      ],
      "kind": "asm_function_def",
      "loc": asm( -> 1 0) extends fun loadCoins(self: Slice): Int {
    LDVARUINT16
},
      "name": {
        "id": 9,
        "kind": "id",
        "loc": loadCoins,
        "text": "loadCoins",
      },
      "params": [
        {
          "id": 13,
          "kind": "typed_parameter",
          "loc": self: Slice,
          "name": {
            "id": 11,
            "kind": "id",
            "loc": self,
            "text": "self",
          },
          "type": {
            "id": 12,
            "kind": "type_id",
            "loc": Slice,
            "text": "Slice",
          },
        },
      ],
      "return": {
        "id": 10,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [
          {
            "base": 10,
            "id": 7,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          {
            "base": 10,
            "id": 8,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
        ],
      },
    },
    {
      "attributes": [
        {
          "kind": "function_attribute",
          "loc": extends,
          "type": "extends",
        },
      ],
      "id": 24,
      "instructions": [
        "STDICT",
      ],
      "kind": "asm_function_def",
      "loc": asm(c b) extends fun storeDict(b: Builder, c: Cell) {
    STDICT
},
      "name": {
        "id": 17,
        "kind": "id",
        "loc": storeDict,
        "text": "storeDict",
      },
      "params": [
        {
          "id": 20,
          "kind": "typed_parameter",
          "loc": b: Builder,
          "name": {
            "id": 18,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 19,
            "kind": "type_id",
            "loc": Builder,
            "text": "Builder",
          },
        },
        {
          "id": 23,
          "kind": "typed_parameter",
          "loc": c: Cell,
          "name": {
            "id": 21,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 22,
            "kind": "type_id",
            "loc": Cell,
            "text": "Cell",
          },
        },
      ],
      "return": null,
      "shuffle": {
        "args": [
          {
            "id": 15,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          {
            "id": 16,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        ],
        "ret": [],
      },
    },
    {
      "attributes": [
        {
          "kind": "function_attribute",
          "loc": extends,
          "type": "extends",
        },
      ],
      "id": 37,
      "instructions": [
        "LDIX",
      ],
      "kind": "asm_function_def",
      "loc": asm(s len -> 1 0) extends fun loadInt(self: Slice, len: Int): Int {
    LDIX
},
      "name": {
        "id": 29,
        "kind": "id",
        "loc": loadInt,
        "text": "loadInt",
      },
      "params": [
        {
          "id": 33,
          "kind": "typed_parameter",
          "loc": self: Slice,
          "name": {
            "id": 31,
            "kind": "id",
            "loc": self,
            "text": "self",
          },
          "type": {
            "id": 32,
            "kind": "type_id",
            "loc": Slice,
            "text": "Slice",
          },
        },
        {
          "id": 36,
          "kind": "typed_parameter",
          "loc": len: Int,
          "name": {
            "id": 34,
            "kind": "id",
            "loc": len,
            "text": "len",
          },
          "type": {
            "id": 35,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 30,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [
          {
            "id": 25,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          {
            "id": 26,
            "kind": "id",
            "loc": len,
            "text": "len",
          },
        ],
        "ret": [
          {
            "base": 10,
            "id": 27,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          {
            "base": 10,
            "id": 28,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
        ],
      },
    },
    {
      "attributes": [],
      "id": 43,
      "instructions": [
        "x{02}",
        "SDBEGINSQ",
      ],
      "kind": "asm_function_def",
      "loc": asm fun checkAndRemoveAddExtensionPrefix(self: Slice): Int {
    x{02} SDBEGINSQ
},
      "name": {
        "id": 38,
        "kind": "id",
        "loc": checkAndRemoveAddExtensionPrefix,
        "text": "checkAndRemoveAddExtensionPrefix",
      },
      "params": [
        {
          "id": 42,
          "kind": "typed_parameter",
          "loc": self: Slice,
          "name": {
            "id": 40,
            "kind": "id",
            "loc": self,
            "text": "self",
          },
          "type": {
            "id": 41,
            "kind": "type_id",
            "loc": Slice,
            "text": "Slice",
          },
        },
      ],
      "return": {
        "id": 39,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 45,
      "instructions": [
        "-ROT",
      ],
      "kind": "asm_function_def",
      "loc": asm fun checkAndRemoveAddExtensionPrefix() {
    -ROT
},
      "name": {
        "id": 44,
        "kind": "id",
        "loc": checkAndRemoveAddExtensionPrefix,
        "text": "checkAndRemoveAddExtensionPrefix",
      },
      "params": [],
      "return": null,
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 47,
      "instructions": [
        ""Works!"",
        "DEBUGSTR",
      ],
      "kind": "asm_function_def",
      "loc": asm fun debugStr1() {
    "Works!" DEBUGSTR
},
      "name": {
        "id": 46,
        "kind": "id",
        "loc": debugStr1,
        "text": "debugStr1",
      },
      "params": [],
      "return": null,
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 49,
      "instructions": [
        ""Works!"",
      ],
      "kind": "asm_function_def",
      "loc": asm fun debugStr2() { "Works!" },
      "name": {
        "id": 48,
        "kind": "id",
        "loc": debugStr2,
        "text": "debugStr2",
      },
      "params": [],
      "return": null,
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 51,
      "instructions": [
        "{ INC }",
      ],
      "kind": "asm_function_def",
      "loc": asm fun createWord() {
    { INC }
},
      "name": {
        "id": 50,
        "kind": "id",
        "loc": createWord,
        "text": "createWord",
      },
      "params": [],
      "return": null,
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 54,
      "instructions": [
        "{ INC }",
        ":",
        "incinc",
        "41",
        "incinc",
      ],
      "kind": "asm_function_def",
      "loc": asm fun createAndUseWord1(): Int {
    { INC } : incinc
    41 incinc
},
      "name": {
        "id": 52,
        "kind": "id",
        "loc": createAndUseWord1,
        "text": "createAndUseWord1",
      },
      "params": [],
      "return": {
        "id": 53,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 57,
      "instructions": [
        "{ INC }",
        ":",
        "incinc",
        "41",
        "incinc",
      ],
      "kind": "asm_function_def",
      "loc": asm fun createAndUseWord2(): Int { { INC
}
: incinc 41 incinc
},
      "name": {
        "id": 55,
        "kind": "id",
        "loc": createAndUseWord2,
        "text": "createAndUseWord2",
      },
      "params": [],
      "return": {
        "id": 56,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 60,
      "instructions": [
        "{ INC }",
        ":",
        "incinc",
        "41",
        "incinc",
      ],
      "kind": "asm_function_def",
      "loc": asm fun createAndUseWord3(): Int {
{
INC
}
:
incinc
41
incinc
},
      "name": {
        "id": 58,
        "kind": "id",
        "loc": createAndUseWord3,
        "text": "createAndUseWord3",
      },
      "params": [],
      "return": {
        "id": 59,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
    {
      "attributes": [],
      "id": 66,
      "instructions": [
        "<{",
        "TRY:<{",
        "0",
        "PUSHINT",
        "ADD",
        "DROP",
        "-1",
        "PUSHINT",
        "}>CATCH<{",
        "2DROP",
        "0",
        "PUSHINT",
        "}>",
        "}>CONT",
        "1",
        "1",
        "CALLXARGS",
      ],
      "kind": "asm_function_def",
      "loc": asm fun isIntAnInt(x: Int): Int {
    <{
        TRY:<{
            0 PUSHINT ADD DROP -1 PUSHINT
        }>CATCH<{
            2DROP 0 PUSHINT
        }>
    }>CONT 1 1 CALLXARGS
},
      "name": {
        "id": 61,
        "kind": "id",
        "loc": isIntAnInt,
        "text": "isIntAnInt",
      },
      "params": [
        {
          "id": 65,
          "kind": "typed_parameter",
          "loc": x: Int,
          "name": {
            "id": 63,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 64,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 62,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "shuffle": {
        "args": [],
        "ret": [],
      },
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse items-method-def-initof-trailing-comma-shifts 1`] = `
{
  "id": 111,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 19,
      "kind": "function_def",
      "loc": fun function(a: Int, b: Int): Int {
    return (a >> b) || (a << (32 - b));
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": function,
        "text": "function",
      },
      "params": [
        {
          "id": 5,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 8,
          "kind": "typed_parameter",
          "loc": b: Int,
          "name": {
            "id": 6,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 7,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 17,
            "kind": "op_binary",
            "left": {
              "id": 11,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a >> b,
              "op": ">>",
              "right": {
                "id": 10,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
            },
            "loc": (a >> b) || (a << (32 - b)),
            "op": "||",
            "right": {
              "id": 16,
              "kind": "op_binary",
              "left": {
                "id": 12,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a << (32 - b),
              "op": "<<",
              "right": {
                "id": 15,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 13,
                  "kind": "number",
                  "loc": 32,
                  "value": 32n,
                },
                "loc": 32 - b,
                "op": "-",
                "right": {
                  "id": 14,
                  "kind": "id",
                  "loc": b,
                  "text": "b",
                },
              },
            },
          },
          "id": 18,
          "kind": "statement_return",
          "loc": return (a >> b) || (a << (32 - b));,
        },
      ],
    },
    {
      "attributes": [],
      "id": 38,
      "kind": "function_def",
      "loc": fun anotherFunction(
    a: Int,
    b: Int,
    ): Int {
    return (a >> b) || (a << (32 - b));
},
      "name": {
        "id": 20,
        "kind": "id",
        "loc": anotherFunction,
        "text": "anotherFunction",
      },
      "params": [
        {
          "id": 24,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 22,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 23,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 27,
          "kind": "typed_parameter",
          "loc": b: Int,
          "name": {
            "id": 25,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 26,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 21,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 36,
            "kind": "op_binary",
            "left": {
              "id": 30,
              "kind": "op_binary",
              "left": {
                "id": 28,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a >> b,
              "op": ">>",
              "right": {
                "id": 29,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
            },
            "loc": (a >> b) || (a << (32 - b)),
            "op": "||",
            "right": {
              "id": 35,
              "kind": "op_binary",
              "left": {
                "id": 31,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              "loc": a << (32 - b),
              "op": "<<",
              "right": {
                "id": 34,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 32,
                  "kind": "number",
                  "loc": 32,
                  "value": 32n,
                },
                "loc": 32 - b,
                "op": "-",
                "right": {
                  "id": 33,
                  "kind": "id",
                  "loc": b,
                  "text": "b",
                },
              },
            },
          },
          "id": 37,
          "kind": "statement_return",
          "loc": return (a >> b) || (a << (32 - b));,
        },
      ],
    },
    {
      "attributes": [
        {
          "kind": "function_attribute",
          "loc": extends,
          "type": "extends",
        },
      ],
      "id": 55,
      "kind": "function_def",
      "loc": extends fun extension(self: Int, c: Int, d: Int) {
    return self + c + d;
},
      "name": {
        "id": 39,
        "kind": "id",
        "loc": extension,
        "text": "extension",
      },
      "params": [
        {
          "id": 42,
          "kind": "typed_parameter",
          "loc": self: Int,
          "name": {
            "id": 40,
            "kind": "id",
            "loc": self,
            "text": "self",
          },
          "type": {
            "id": 41,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 45,
          "kind": "typed_parameter",
          "loc": c: Int,
          "name": {
            "id": 43,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 44,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 48,
          "kind": "typed_parameter",
          "loc": d: Int,
          "name": {
            "id": 46,
            "kind": "id",
            "loc": d,
            "text": "d",
          },
          "type": {
            "id": 47,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": null,
      "statements": [
        {
          "expression": {
            "id": 53,
            "kind": "op_binary",
            "left": {
              "id": 51,
              "kind": "op_binary",
              "left": {
                "id": 49,
                "kind": "id",
                "loc": self,
                "text": "self",
              },
              "loc": self + c,
              "op": "+",
              "right": {
                "id": 50,
                "kind": "id",
                "loc": c,
                "text": "c",
              },
            },
            "loc": self + c + d,
            "op": "+",
            "right": {
              "id": 52,
              "kind": "id",
              "loc": d,
              "text": "d",
            },
          },
          "id": 54,
          "kind": "statement_return",
          "loc": return self + c + d;,
        },
      ],
    },
    {
      "attributes": [],
      "id": 78,
      "kind": "function_def",
      "loc": fun coverage(a: Int, b: Int) {
    let k: Int = a.extension(
        b,
        4,
    );

    let c: Int = anotherFunction(
        a,
        b,
    );
},
      "name": {
        "id": 56,
        "kind": "id",
        "loc": coverage,
        "text": "coverage",
      },
      "params": [
        {
          "id": 59,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 57,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 58,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 62,
          "kind": "typed_parameter",
          "loc": b: Int,
          "name": {
            "id": 60,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 61,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": null,
      "statements": [
        {
          "expression": {
            "args": [
              {
                "id": 67,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              {
                "base": 10,
                "id": 68,
                "kind": "number",
                "loc": 4,
                "value": 4n,
              },
            ],
            "id": 69,
            "kind": "method_call",
            "loc": a.extension(
        b,
        4,
    ),
            "method": {
              "id": 66,
              "kind": "id",
              "loc": extension,
              "text": "extension",
            },
            "self": {
              "id": 65,
              "kind": "id",
              "loc": a,
              "text": "a",
            },
          },
          "id": 70,
          "kind": "statement_let",
          "loc": let k: Int = a.extension(
        b,
        4,
    );,
          "name": {
            "id": 63,
            "kind": "id",
            "loc": k,
            "text": "k",
          },
          "type": {
            "id": 64,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "args": [
              {
                "id": 74,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 75,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
            ],
            "function": {
              "id": 73,
              "kind": "id",
              "loc": anotherFunction,
              "text": "anotherFunction",
            },
            "id": 76,
            "kind": "static_call",
            "loc": anotherFunction(
        a,
        b,
    ),
          },
          "id": 77,
          "kind": "statement_let",
          "loc": let c: Int = anotherFunction(
        a,
        b,
    );,
          "name": {
            "id": 71,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 72,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
    },
    {
      "attributes": [],
      "id": 92,
      "kind": "function_def",
      "loc": fun oneMoreFunction(
    a: Int,
    b: Int,
    ): Int {
    return anotherFunction(
        a,
        b,
    );
},
      "name": {
        "id": 79,
        "kind": "id",
        "loc": oneMoreFunction,
        "text": "oneMoreFunction",
      },
      "params": [
        {
          "id": 83,
          "kind": "typed_parameter",
          "loc": a: Int,
          "name": {
            "id": 81,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 82,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "id": 86,
          "kind": "typed_parameter",
          "loc": b: Int,
          "name": {
            "id": 84,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 85,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "return": {
        "id": 80,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "args": [
              {
                "id": 88,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 89,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
            ],
            "function": {
              "id": 87,
              "kind": "id",
              "loc": anotherFunction,
              "text": "anotherFunction",
            },
            "id": 90,
            "kind": "static_call",
            "loc": anotherFunction(
        a,
        b,
    ),
          },
          "id": 91,
          "kind": "statement_return",
          "loc": return anotherFunction(
        a,
        b,
    );,
        },
      ],
    },
    {
      "attributes": [],
      "declarations": [
        {
          "id": 100,
          "kind": "contract_init",
          "loc": init(
        arg1: Int,
        arg2: Int,
    ) {},
          "params": [
            {
              "id": 96,
              "kind": "typed_parameter",
              "loc": arg1: Int,
              "name": {
                "id": 94,
                "kind": "id",
                "loc": arg1,
                "text": "arg1",
              },
              "type": {
                "id": 95,
                "kind": "type_id",
                "loc": Int,
                "text": "Int",
              },
            },
            {
              "id": 99,
              "kind": "typed_parameter",
              "loc": arg2: Int,
              "name": {
                "id": 97,
                "kind": "id",
                "loc": arg2,
                "text": "arg2",
              },
              "type": {
                "id": 98,
                "kind": "type_id",
                "loc": Int,
                "text": "Int",
              },
            },
          ],
          "statements": [],
        },
      ],
      "id": 101,
      "kind": "contract",
      "loc": contract TestContract {
    init(
        arg1: Int,
        arg2: Int,
    ) {}
},
      "name": {
        "id": 93,
        "kind": "id",
        "loc": TestContract,
        "text": "TestContract",
      },
      "traits": [],
    },
    {
      "attributes": [],
      "id": 110,
      "kind": "function_def",
      "loc": fun test() {
    let k: StateInit = initOf TestContract(
        2,
        3,
    );
},
      "name": {
        "id": 102,
        "kind": "id",
        "loc": test,
        "text": "test",
      },
      "params": [],
      "return": null,
      "statements": [
        {
          "expression": {
            "args": [
              {
                "base": 10,
                "id": 106,
                "kind": "number",
                "loc": 2,
                "value": 2n,
              },
              {
                "base": 10,
                "id": 107,
                "kind": "number",
                "loc": 3,
                "value": 3n,
              },
            ],
            "contract": {
              "id": 105,
              "kind": "id",
              "loc": TestContract,
              "text": "TestContract",
            },
            "id": 108,
            "kind": "init_of",
            "loc": initOf TestContract(
        2,
        3,
    ),
          },
          "id": 109,
          "kind": "statement_let",
          "loc": let k: StateInit = initOf TestContract(
        2,
        3,
    );,
          "name": {
            "id": 103,
            "kind": "id",
            "loc": k,
            "text": "k",
          },
          "type": {
            "id": 104,
            "kind": "type_id",
            "loc": StateInit,
            "text": "StateInit",
          },
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse items-multi-funs 1`] = `
{
  "id": 15,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 4,
      "kind": "function_def",
      "loc": fun testFunc() {
    return 0;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": null,
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 2,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
          "id": 3,
          "kind": "statement_return",
          "loc": return 0;,
        },
      ],
    },
    {
      "attributes": [],
      "id": 9,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    return 0;
},
      "name": {
        "id": 5,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 6,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 7,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
          "id": 8,
          "kind": "statement_return",
          "loc": return 0;,
        },
      ],
    },
    {
      "attributes": [],
      "id": 14,
      "kind": "function_def",
      "loc": fun testFunc(): Bool {
    return 0;
},
      "name": {
        "id": 10,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 11,
        "kind": "type_id",
        "loc": Bool,
        "text": "Bool",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 12,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
          "id": 13,
          "kind": "statement_return",
          "loc": return 0;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse items-native-fun-decls 1`] = `
{
  "id": 12,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 3,
      "kind": "native_function_decl",
      "loc": @name(native_name_1)
native testFunc();,
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "nativeName": {
        "id": 2,
        "kind": "func_id",
        "loc": native_name_1,
        "text": "native_name_1",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 7,
      "kind": "native_function_decl",
      "loc": @name(native_name_2)
native testFunc(): Int;,
      "name": {
        "id": 4,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "nativeName": {
        "id": 5,
        "kind": "func_id",
        "loc": native_name_2,
        "text": "native_name_2",
      },
      "params": [],
      "return": {
        "id": 6,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
    },
    {
      "attributes": [],
      "id": 11,
      "kind": "native_function_decl",
      "loc": @name(native_name_3)
native testFunc(): Bool;,
      "name": {
        "id": 8,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "nativeName": {
        "id": 9,
        "kind": "func_id",
        "loc": native_name_3,
        "text": "native_name_3",
      },
      "params": [],
      "return": {
        "id": 10,
        "kind": "type_id",
        "loc": Bool,
        "text": "Bool",
      },
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse items-native-fun-funcid 1`] = `
{
  "id": 124,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 3,
      "kind": "native_function_decl",
      "loc": @name(query')
native idTest1();,
      "name": {
        "id": 1,
        "kind": "id",
        "loc": idTest1,
        "text": "idTest1",
      },
      "nativeName": {
        "id": 2,
        "kind": "func_id",
        "loc": query',
        "text": "query'",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 6,
      "kind": "native_function_decl",
      "loc": @name(query'')
native idTest2();,
      "name": {
        "id": 4,
        "kind": "id",
        "loc": idTest2,
        "text": "idTest2",
      },
      "nativeName": {
        "id": 5,
        "kind": "func_id",
        "loc": query'',
        "text": "query''",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 9,
      "kind": "native_function_decl",
      "loc": @name(CHECK)
native idTest3();,
      "name": {
        "id": 7,
        "kind": "id",
        "loc": idTest3,
        "text": "idTest3",
      },
      "nativeName": {
        "id": 8,
        "kind": "func_id",
        "loc": CHECK,
        "text": "CHECK",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 12,
      "kind": "native_function_decl",
      "loc": @name(_internal_val)
native idTest4();,
      "name": {
        "id": 10,
        "kind": "id",
        "loc": idTest4,
        "text": "idTest4",
      },
      "nativeName": {
        "id": 11,
        "kind": "func_id",
        "loc": _internal_val,
        "text": "_internal_val",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 15,
      "kind": "native_function_decl",
      "loc": @name(message_found?)
native idTest5();,
      "name": {
        "id": 13,
        "kind": "id",
        "loc": idTest5,
        "text": "idTest5",
      },
      "nativeName": {
        "id": 14,
        "kind": "func_id",
        "loc": message_found?,
        "text": "message_found?",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 18,
      "kind": "native_function_decl",
      "loc": @name(get_pubkeys&signatures)
native idTest6();,
      "name": {
        "id": 16,
        "kind": "id",
        "loc": idTest6,
        "text": "idTest6",
      },
      "nativeName": {
        "id": 17,
        "kind": "func_id",
        "loc": get_pubkeys&signatures,
        "text": "get_pubkeys&signatures",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 21,
      "kind": "native_function_decl",
      "loc": @name(dict::udict_set_builder)
native idTest7();,
      "name": {
        "id": 19,
        "kind": "id",
        "loc": idTest7,
        "text": "idTest7",
      },
      "nativeName": {
        "id": 20,
        "kind": "func_id",
        "loc": dict::udict_set_builder,
        "text": "dict::udict_set_builder",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 24,
      "kind": "native_function_decl",
      "loc": @name(_+_)
native idTest8();,
      "name": {
        "id": 22,
        "kind": "id",
        "loc": idTest8,
        "text": "idTest8",
      },
      "nativeName": {
        "id": 23,
        "kind": "func_id",
        "loc": _+_,
        "text": "_+_",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 27,
      "kind": "native_function_decl",
      "loc": @name(__)
native idTest9();,
      "name": {
        "id": 25,
        "kind": "id",
        "loc": idTest9,
        "text": "idTest9",
      },
      "nativeName": {
        "id": 26,
        "kind": "func_id",
        "loc": __,
        "text": "__",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 30,
      "kind": "native_function_decl",
      "loc": @name(fatal!)
native idTest10();,
      "name": {
        "id": 28,
        "kind": "id",
        "loc": idTest10,
        "text": "idTest10",
      },
      "nativeName": {
        "id": 29,
        "kind": "func_id",
        "loc": fatal!,
        "text": "fatal!",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 33,
      "kind": "native_function_decl",
      "loc": @name(123validname)
native idTest11();,
      "name": {
        "id": 31,
        "kind": "id",
        "loc": idTest11,
        "text": "idTest11",
      },
      "nativeName": {
        "id": 32,
        "kind": "func_id",
        "loc": 123validname,
        "text": "123validname",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 36,
      "kind": "native_function_decl",
      "loc": @name(2+2=2*2)
native idTest12();,
      "name": {
        "id": 34,
        "kind": "id",
        "loc": idTest12,
        "text": "idTest12",
      },
      "nativeName": {
        "id": 35,
        "kind": "func_id",
        "loc": 2+2=2*2,
        "text": "2+2=2*2",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 39,
      "kind": "native_function_decl",
      "loc": @name(-alsovalidname)
native idTest13();,
      "name": {
        "id": 37,
        "kind": "id",
        "loc": idTest13,
        "text": "idTest13",
      },
      "nativeName": {
        "id": 38,
        "kind": "func_id",
        "loc": -alsovalidname,
        "text": "-alsovalidname",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 42,
      "kind": "native_function_decl",
      "loc": @name(0xefefefhahaha)
native idTest14();,
      "name": {
        "id": 40,
        "kind": "id",
        "loc": idTest14,
        "text": "idTest14",
      },
      "nativeName": {
        "id": 41,
        "kind": "func_id",
        "loc": 0xefefefhahaha,
        "text": "0xefefefhahaha",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 45,
      "kind": "native_function_decl",
      "loc": @name({hehehe})
native idTest15();,
      "name": {
        "id": 43,
        "kind": "id",
        "loc": idTest15,
        "text": "idTest15",
      },
      "nativeName": {
        "id": 44,
        "kind": "func_id",
        "loc": {hehehe},
        "text": "{hehehe}",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 48,
      "kind": "native_function_decl",
      "loc": @name(pa{--}in"\`aaa\`")
native idTest16();,
      "name": {
        "id": 46,
        "kind": "id",
        "loc": idTest16,
        "text": "idTest16",
      },
      "nativeName": {
        "id": 47,
        "kind": "func_id",
        "loc": pa{--}in"\`aaa\`",
        "text": "pa{--}in"\`aaa\`"",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 51,
      "kind": "native_function_decl",
      "loc": @name(\`I'm a function too\`)
native idTest17();,
      "name": {
        "id": 49,
        "kind": "id",
        "loc": idTest17,
        "text": "idTest17",
      },
      "nativeName": {
        "id": 50,
        "kind": "func_id",
        "loc": \`I'm a function too\`,
        "text": "\`I'm a function too\`",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 54,
      "kind": "native_function_decl",
      "loc": @name(\`any symbols ; ~ () are allowed here...\`)
native idTest18();,
      "name": {
        "id": 52,
        "kind": "id",
        "loc": idTest18,
        "text": "idTest18",
      },
      "nativeName": {
        "id": 53,
        "kind": "func_id",
        "loc": \`any symbols ; ~ () are allowed here...\`,
        "text": "\`any symbols ; ~ () are allowed here...\`",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 57,
      "kind": "native_function_decl",
      "loc": @name(C4)
native idTest19();,
      "name": {
        "id": 55,
        "kind": "id",
        "loc": idTest19,
        "text": "idTest19",
      },
      "nativeName": {
        "id": 56,
        "kind": "func_id",
        "loc": C4,
        "text": "C4",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 60,
      "kind": "native_function_decl",
      "loc": @name(C4g)
native idTest20();,
      "name": {
        "id": 58,
        "kind": "id",
        "loc": idTest20,
        "text": "idTest20",
      },
      "nativeName": {
        "id": 59,
        "kind": "func_id",
        "loc": C4g,
        "text": "C4g",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 63,
      "kind": "native_function_decl",
      "loc": @name(4C)
native idTest21();,
      "name": {
        "id": 61,
        "kind": "id",
        "loc": idTest21,
        "text": "idTest21",
      },
      "nativeName": {
        "id": 62,
        "kind": "func_id",
        "loc": 4C,
        "text": "4C",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 66,
      "kind": "native_function_decl",
      "loc": @name(_0x0)
native idTest22();,
      "name": {
        "id": 64,
        "kind": "id",
        "loc": idTest22,
        "text": "idTest22",
      },
      "nativeName": {
        "id": 65,
        "kind": "func_id",
        "loc": _0x0,
        "text": "_0x0",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 69,
      "kind": "native_function_decl",
      "loc": @name(_0)
native idTest23();,
      "name": {
        "id": 67,
        "kind": "id",
        "loc": idTest23,
        "text": "idTest23",
      },
      "nativeName": {
        "id": 68,
        "kind": "func_id",
        "loc": _0,
        "text": "_0",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 72,
      "kind": "native_function_decl",
      "loc": @name(0x_)
native idTest24();,
      "name": {
        "id": 70,
        "kind": "id",
        "loc": idTest24,
        "text": "idTest24",
      },
      "nativeName": {
        "id": 71,
        "kind": "func_id",
        "loc": 0x_,
        "text": "0x_",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 75,
      "kind": "native_function_decl",
      "loc": @name(0x0_)
native idTest25();,
      "name": {
        "id": 73,
        "kind": "id",
        "loc": idTest25,
        "text": "idTest25",
      },
      "nativeName": {
        "id": 74,
        "kind": "func_id",
        "loc": 0x0_,
        "text": "0x0_",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 78,
      "kind": "native_function_decl",
      "loc": @name(0_)
native idTest26();,
      "name": {
        "id": 76,
        "kind": "id",
        "loc": idTest26,
        "text": "idTest26",
      },
      "nativeName": {
        "id": 77,
        "kind": "func_id",
        "loc": 0_,
        "text": "0_",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 81,
      "kind": "native_function_decl",
      "loc": @name(hash#256)
native idTest27();,
      "name": {
        "id": 79,
        "kind": "id",
        "loc": idTest27,
        "text": "idTest27",
      },
      "nativeName": {
        "id": 80,
        "kind": "func_id",
        "loc": hash#256,
        "text": "hash#256",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 84,
      "kind": "native_function_decl",
      "loc": @name(💀💀💀0xDEADBEEF💀💀💀)
native idTest28();,
      "name": {
        "id": 82,
        "kind": "id",
        "loc": idTest28,
        "text": "idTest28",
      },
      "nativeName": {
        "id": 83,
        "kind": "func_id",
        "loc": 💀💀💀0xDEADBEEF💀💀💀,
        "text": "💀💀💀0xDEADBEEF💀💀💀",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 87,
      "kind": "native_function_decl",
      "loc": @name(__tact_verify_address)
native idTest29();,
      "name": {
        "id": 85,
        "kind": "id",
        "loc": idTest29,
        "text": "idTest29",
      },
      "nativeName": {
        "id": 86,
        "kind": "func_id",
        "loc": __tact_verify_address,
        "text": "__tact_verify_address",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 90,
      "kind": "native_function_decl",
      "loc": @name(__tact_pow2)
native idTest30();,
      "name": {
        "id": 88,
        "kind": "id",
        "loc": idTest30,
        "text": "idTest30",
      },
      "nativeName": {
        "id": 89,
        "kind": "func_id",
        "loc": __tact_pow2,
        "text": "__tact_pow2",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 93,
      "kind": "native_function_decl",
      "loc": @name(randomize_lt)
native idTest31();,
      "name": {
        "id": 91,
        "kind": "id",
        "loc": idTest31,
        "text": "idTest31",
      },
      "nativeName": {
        "id": 92,
        "kind": "func_id",
        "loc": randomize_lt,
        "text": "randomize_lt",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 96,
      "kind": "native_function_decl",
      "loc": @name(fixed248::asin)
native idTest32();,
      "name": {
        "id": 94,
        "kind": "id",
        "loc": idTest32,
        "text": "idTest32",
      },
      "nativeName": {
        "id": 95,
        "kind": "func_id",
        "loc": fixed248::asin,
        "text": "fixed248::asin",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 99,
      "kind": "native_function_decl",
      "loc": @name(fixed248::nrand_fast)
native idTest33();,
      "name": {
        "id": 97,
        "kind": "id",
        "loc": idTest33,
        "text": "idTest33",
      },
      "nativeName": {
        "id": 98,
        "kind": "func_id",
        "loc": fixed248::nrand_fast,
        "text": "fixed248::nrand_fast",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 102,
      "kind": "native_function_decl",
      "loc": @name(atan_f261_inlined)
native idTest34();,
      "name": {
        "id": 100,
        "kind": "id",
        "loc": idTest34,
        "text": "idTest34",
      },
      "nativeName": {
        "id": 101,
        "kind": "func_id",
        "loc": atan_f261_inlined,
        "text": "atan_f261_inlined",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 105,
      "kind": "native_function_decl",
      "loc": @name(~impure_touch)
native idTest35();,
      "name": {
        "id": 103,
        "kind": "id",
        "loc": idTest35,
        "text": "idTest35",
      },
      "nativeName": {
        "id": 104,
        "kind": "func_id",
        "loc": ~impure_touch,
        "text": "~impure_touch",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 108,
      "kind": "native_function_decl",
      "loc": @name(~udict::delete_get_min)
native idTest36();,
      "name": {
        "id": 106,
        "kind": "id",
        "loc": idTest36,
        "text": "idTest36",
      },
      "nativeName": {
        "id": 107,
        "kind": "func_id",
        "loc": ~udict::delete_get_min,
        "text": "~udict::delete_get_min",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 111,
      "kind": "native_function_decl",
      "loc": @name(.something)
native idTest37();,
      "name": {
        "id": 109,
        "kind": "id",
        "loc": idTest37,
        "text": "idTest37",
      },
      "nativeName": {
        "id": 110,
        "kind": "func_id",
        "loc": .something,
        "text": ".something",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 114,
      "kind": "native_function_decl",
      "loc": @name(f̷̨͈͚́͌̀i̵̩͔̭̐͐̊n̸̟̝̻̩̎̓͋̕e̸̝̙̒̿͒̾̕)
native idTest38();,
      "name": {
        "id": 112,
        "kind": "id",
        "loc": idTest38,
        "text": "idTest38",
      },
      "nativeName": {
        "id": 113,
        "kind": "func_id",
        "loc": f̷̨͈͚́͌̀i̵̩͔̭̐͐̊n̸̟̝̻̩̎̓͋̕e̸̝̙̒̿͒̾̕,
        "text": "f̷̨͈͚́͌̀i̵̩͔̭̐͐̊n̸̟̝̻̩̎̓͋̕e̸̝̙̒̿͒̾̕",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 117,
      "kind": "native_function_decl",
      "loc": @name(❤️❤️❤️thanks❤️❤️❤️)
native idTest39();,
      "name": {
        "id": 115,
        "kind": "id",
        "loc": idTest39,
        "text": "idTest39",
      },
      "nativeName": {
        "id": 116,
        "kind": "func_id",
        "loc": ❤️❤️❤️thanks❤️❤️❤️,
        "text": "❤️❤️❤️thanks❤️❤️❤️",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 120,
      "kind": "native_function_decl",
      "loc": @name(intslice)
native idTest40();,
      "name": {
        "id": 118,
        "kind": "id",
        "loc": idTest40,
        "text": "idTest40",
      },
      "nativeName": {
        "id": 119,
        "kind": "func_id",
        "loc": intslice,
        "text": "intslice",
      },
      "params": [],
      "return": null,
    },
    {
      "attributes": [],
      "id": 123,
      "kind": "native_function_decl",
      "loc": @name(int2)
native idTest40();,
      "name": {
        "id": 121,
        "kind": "id",
        "loc": idTest40,
        "text": "idTest40",
      },
      "nativeName": {
        "id": 122,
        "kind": "func_id",
        "loc": int2,
        "text": "int2",
      },
      "params": [],
      "return": null,
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse items-struct-msg-fun-const 1`] = `
{
  "id": 60,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 4,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 7,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 5,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 6,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 8,
      "kind": "struct_decl",
      "loc": struct A {
    x: Int;
    y: Int;
},
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "attributes": [],
      "id": 16,
      "initializer": {
        "args": [
          {
            "field": {
              "id": 12,
              "kind": "id",
              "loc": x,
              "text": "x",
            },
            "id": 14,
            "initializer": {
              "base": 10,
              "id": 13,
              "kind": "number",
              "loc": 1,
              "value": 1n,
            },
            "kind": "struct_field_initializer",
            "loc": x: 1,
          },
        ],
        "id": 15,
        "kind": "struct_instance",
        "loc": A { x: 1 },
        "type": {
          "id": 11,
          "kind": "type_id",
          "loc": A,
          "text": "A",
        },
      },
      "kind": "constant_def",
      "loc": const a: A = A { x: 1 };,
      "name": {
        "id": 9,
        "kind": "id",
        "loc": a,
        "text": "a",
      },
      "type": {
        "id": 10,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "attributes": [],
      "id": 28,
      "kind": "function_def",
      "loc": fun getA(): A {
    return A {
        x: 1,
        y: 2,
    };
},
      "name": {
        "id": 17,
        "kind": "id",
        "loc": getA,
        "text": "getA",
      },
      "params": [],
      "return": {
        "id": 18,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
      "statements": [
        {
          "expression": {
            "args": [
              {
                "field": {
                  "id": 20,
                  "kind": "id",
                  "loc": x,
                  "text": "x",
                },
                "id": 22,
                "initializer": {
                  "base": 10,
                  "id": 21,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "kind": "struct_field_initializer",
                "loc": x: 1,
              },
              {
                "field": {
                  "id": 23,
                  "kind": "id",
                  "loc": y,
                  "text": "y",
                },
                "id": 25,
                "initializer": {
                  "base": 10,
                  "id": 24,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
                "kind": "struct_field_initializer",
                "loc": y: 2,
              },
            ],
            "id": 26,
            "kind": "struct_instance",
            "loc": A {
        x: 1,
        y: 2,
    },
            "type": {
              "id": 19,
              "kind": "type_id",
              "loc": A,
              "text": "A",
            },
          },
          "id": 27,
          "kind": "statement_return",
          "loc": return A {
        x: 1,
        y: 2,
    };,
        },
      ],
    },
    {
      "fields": [
        {
          "as": null,
          "id": 32,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 30,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 31,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 35,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 33,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 34,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 36,
      "kind": "message_decl",
      "loc": message B {
    x: Int;
    y: Int;
},
      "name": {
        "id": 29,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
      "opcode": null,
    },
    {
      "attributes": [],
      "id": 47,
      "initializer": {
        "args": [
          {
            "field": {
              "id": 40,
              "kind": "id",
              "loc": x,
              "text": "x",
            },
            "id": 42,
            "initializer": {
              "base": 10,
              "id": 41,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
            "kind": "struct_field_initializer",
            "loc": x: 2,
          },
          {
            "field": {
              "id": 43,
              "kind": "id",
              "loc": y,
              "text": "y",
            },
            "id": 45,
            "initializer": {
              "base": 10,
              "id": 44,
              "kind": "number",
              "loc": 3,
              "value": 3n,
            },
            "kind": "struct_field_initializer",
            "loc": y: 3,
          },
        ],
        "id": 46,
        "kind": "struct_instance",
        "loc": B {
    x: 2,
    y: 3,
},
        "type": {
          "id": 39,
          "kind": "type_id",
          "loc": B,
          "text": "B",
        },
      },
      "kind": "constant_def",
      "loc": const b: B = B {
    x: 2,
    y: 3,
};,
      "name": {
        "id": 37,
        "kind": "id",
        "loc": b,
        "text": "b",
      },
      "type": {
        "id": 38,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
    },
    {
      "attributes": [],
      "id": 59,
      "kind": "function_def",
      "loc": fun getB(): B {
    return B { x: 1, y: 5, };
},
      "name": {
        "id": 48,
        "kind": "id",
        "loc": getB,
        "text": "getB",
      },
      "params": [],
      "return": {
        "id": 49,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
      "statements": [
        {
          "expression": {
            "args": [
              {
                "field": {
                  "id": 51,
                  "kind": "id",
                  "loc": x,
                  "text": "x",
                },
                "id": 53,
                "initializer": {
                  "base": 10,
                  "id": 52,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "kind": "struct_field_initializer",
                "loc": x: 1,
              },
              {
                "field": {
                  "id": 54,
                  "kind": "id",
                  "loc": y,
                  "text": "y",
                },
                "id": 56,
                "initializer": {
                  "base": 10,
                  "id": 55,
                  "kind": "number",
                  "loc": 5,
                  "value": 5n,
                },
                "kind": "struct_field_initializer",
                "loc": y: 5,
              },
            ],
            "id": 57,
            "kind": "struct_instance",
            "loc": B { x: 1, y: 5, },
            "type": {
              "id": 50,
              "kind": "type_id",
              "loc": B,
              "text": "B",
            },
          },
          "id": 58,
          "kind": "statement_return",
          "loc": return B { x: 1, y: 5, };,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse literals-int-underscores-bin-dec-hex-oct 1`] = `
{
  "id": 80,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 79,
      "kind": "function_def",
      "loc": fun test_fun(): Int {
    let a: Int = 123;
    let b: Int = -123;
    let c: Int = 1_0123_00_000;
    let d: Int = 0x123;
    let e: Int = -0x123;
    let f: Int = 0x1_0123_00_000;
    let g: Int = 0b101010;
    let h: Int = -0b101010;
    let i: Int = 0b1_0101_00_000;
    let j: Int = 0o123;
    let k: Int = -0o123;
    let l: Int = 0o1_0123_00_000;
    return a + b + c + d + e + f + g + h + i + j + k + l;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": test_fun,
        "text": "test_fun",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 5,
            "kind": "number",
            "loc": 123,
            "value": 123n,
          },
          "id": 6,
          "kind": "statement_let",
          "loc": let a: Int = 123;,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 10,
            "kind": "op_unary",
            "loc": -123,
            "op": "-",
            "operand": {
              "base": 10,
              "id": 9,
              "kind": "number",
              "loc": 123,
              "value": 123n,
            },
          },
          "id": 11,
          "kind": "statement_let",
          "loc": let b: Int = -123;,
          "name": {
            "id": 7,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 14,
            "kind": "number",
            "loc": 1_0123_00_000,
            "value": 1012300000n,
          },
          "id": 15,
          "kind": "statement_let",
          "loc": let c: Int = 1_0123_00_000;,
          "name": {
            "id": 12,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 13,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 16,
            "id": 18,
            "kind": "number",
            "loc": 0x123,
            "value": 291n,
          },
          "id": 19,
          "kind": "statement_let",
          "loc": let d: Int = 0x123;,
          "name": {
            "id": 16,
            "kind": "id",
            "loc": d,
            "text": "d",
          },
          "type": {
            "id": 17,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 23,
            "kind": "op_unary",
            "loc": -0x123,
            "op": "-",
            "operand": {
              "base": 16,
              "id": 22,
              "kind": "number",
              "loc": 0x123,
              "value": 291n,
            },
          },
          "id": 24,
          "kind": "statement_let",
          "loc": let e: Int = -0x123;,
          "name": {
            "id": 20,
            "kind": "id",
            "loc": e,
            "text": "e",
          },
          "type": {
            "id": 21,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 16,
            "id": 27,
            "kind": "number",
            "loc": 0x1_0123_00_000,
            "value": 69024612352n,
          },
          "id": 28,
          "kind": "statement_let",
          "loc": let f: Int = 0x1_0123_00_000;,
          "name": {
            "id": 25,
            "kind": "id",
            "loc": f,
            "text": "f",
          },
          "type": {
            "id": 26,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 2,
            "id": 31,
            "kind": "number",
            "loc": 0b101010,
            "value": 42n,
          },
          "id": 32,
          "kind": "statement_let",
          "loc": let g: Int = 0b101010;,
          "name": {
            "id": 29,
            "kind": "id",
            "loc": g,
            "text": "g",
          },
          "type": {
            "id": 30,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 36,
            "kind": "op_unary",
            "loc": -0b101010,
            "op": "-",
            "operand": {
              "base": 2,
              "id": 35,
              "kind": "number",
              "loc": 0b101010,
              "value": 42n,
            },
          },
          "id": 37,
          "kind": "statement_let",
          "loc": let h: Int = -0b101010;,
          "name": {
            "id": 33,
            "kind": "id",
            "loc": h,
            "text": "h",
          },
          "type": {
            "id": 34,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 2,
            "id": 40,
            "kind": "number",
            "loc": 0b1_0101_00_000,
            "value": 672n,
          },
          "id": 41,
          "kind": "statement_let",
          "loc": let i: Int = 0b1_0101_00_000;,
          "name": {
            "id": 38,
            "kind": "id",
            "loc": i,
            "text": "i",
          },
          "type": {
            "id": 39,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 8,
            "id": 44,
            "kind": "number",
            "loc": 0o123,
            "value": 83n,
          },
          "id": 45,
          "kind": "statement_let",
          "loc": let j: Int = 0o123;,
          "name": {
            "id": 42,
            "kind": "id",
            "loc": j,
            "text": "j",
          },
          "type": {
            "id": 43,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 49,
            "kind": "op_unary",
            "loc": -0o123,
            "op": "-",
            "operand": {
              "base": 8,
              "id": 48,
              "kind": "number",
              "loc": 0o123,
              "value": 83n,
            },
          },
          "id": 50,
          "kind": "statement_let",
          "loc": let k: Int = -0o123;,
          "name": {
            "id": 46,
            "kind": "id",
            "loc": k,
            "text": "k",
          },
          "type": {
            "id": 47,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 8,
            "id": 53,
            "kind": "number",
            "loc": 0o1_0123_00_000,
            "value": 136937472n,
          },
          "id": 54,
          "kind": "statement_let",
          "loc": let l: Int = 0o1_0123_00_000;,
          "name": {
            "id": 51,
            "kind": "id",
            "loc": l,
            "text": "l",
          },
          "type": {
            "id": 52,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 77,
            "kind": "op_binary",
            "left": {
              "id": 75,
              "kind": "op_binary",
              "left": {
                "id": 73,
                "kind": "op_binary",
                "left": {
                  "id": 71,
                  "kind": "op_binary",
                  "left": {
                    "id": 69,
                    "kind": "op_binary",
                    "left": {
                      "id": 67,
                      "kind": "op_binary",
                      "left": {
                        "id": 65,
                        "kind": "op_binary",
                        "left": {
                          "id": 63,
                          "kind": "op_binary",
                          "left": {
                            "id": 61,
                            "kind": "op_binary",
                            "left": {
                              "id": 59,
                              "kind": "op_binary",
                              "left": {
                                "id": 57,
                                "kind": "op_binary",
                                "left": {
                                  "id": 55,
                                  "kind": "id",
                                  "loc": a,
                                  "text": "a",
                                },
                                "loc": a + b,
                                "op": "+",
                                "right": {
                                  "id": 56,
                                  "kind": "id",
                                  "loc": b,
                                  "text": "b",
                                },
                              },
                              "loc": a + b + c,
                              "op": "+",
                              "right": {
                                "id": 58,
                                "kind": "id",
                                "loc": c,
                                "text": "c",
                              },
                            },
                            "loc": a + b + c + d,
                            "op": "+",
                            "right": {
                              "id": 60,
                              "kind": "id",
                              "loc": d,
                              "text": "d",
                            },
                          },
                          "loc": a + b + c + d + e,
                          "op": "+",
                          "right": {
                            "id": 62,
                            "kind": "id",
                            "loc": e,
                            "text": "e",
                          },
                        },
                        "loc": a + b + c + d + e + f,
                        "op": "+",
                        "right": {
                          "id": 64,
                          "kind": "id",
                          "loc": f,
                          "text": "f",
                        },
                      },
                      "loc": a + b + c + d + e + f + g,
                      "op": "+",
                      "right": {
                        "id": 66,
                        "kind": "id",
                        "loc": g,
                        "text": "g",
                      },
                    },
                    "loc": a + b + c + d + e + f + g + h,
                    "op": "+",
                    "right": {
                      "id": 68,
                      "kind": "id",
                      "loc": h,
                      "text": "h",
                    },
                  },
                  "loc": a + b + c + d + e + f + g + h + i,
                  "op": "+",
                  "right": {
                    "id": 70,
                    "kind": "id",
                    "loc": i,
                    "text": "i",
                  },
                },
                "loc": a + b + c + d + e + f + g + h + i + j,
                "op": "+",
                "right": {
                  "id": 72,
                  "kind": "id",
                  "loc": j,
                  "text": "j",
                },
              },
              "loc": a + b + c + d + e + f + g + h + i + j + k,
              "op": "+",
              "right": {
                "id": 74,
                "kind": "id",
                "loc": k,
                "text": "k",
              },
            },
            "loc": a + b + c + d + e + f + g + h + i + j + k + l,
            "op": "+",
            "right": {
              "id": 76,
              "kind": "id",
              "loc": l,
              "text": "l",
            },
          },
          "id": 78,
          "kind": "statement_return",
          "loc": return a + b + c + d + e + f + g + h + i + j + k + l;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-augmented-assign-arith 1`] = `
{
  "id": 94,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 93,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    let a: Int = 1;
    let b: Int = 2;
    a += b;
    b += a;
    a += 3;
    a += b + 4;
    b -= 1;
    a -= b;
    a -= b - 1;
    b *= 2;
    a *= b;
    a *= b * 2;
    b /= 2;
    a /= b;
    a /= b / 2;
    a %= 2;
    a %= b;
    a %= b % 2;
    a <<= 2;
    a <<= b;
    a <<= b << 2;
    a >>= 2;
    a >>= b;
    a >>= b >> 2;
    return a;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 5,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 6,
          "kind": "statement_let",
          "loc": let a: Int = 1;,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 9,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 10,
          "kind": "statement_let",
          "loc": let b: Int = 2;,
          "name": {
            "id": 7,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 12,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 13,
          "kind": "statement_augmentedassign",
          "loc": a += b;,
          "op": "+",
          "path": {
            "id": 11,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 15,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 16,
          "kind": "statement_augmentedassign",
          "loc": b += a;,
          "op": "+",
          "path": {
            "id": 14,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 18,
            "kind": "number",
            "loc": 3,
            "value": 3n,
          },
          "id": 19,
          "kind": "statement_augmentedassign",
          "loc": a += 3;,
          "op": "+",
          "path": {
            "id": 17,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 23,
            "kind": "op_binary",
            "left": {
              "id": 21,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b + 4,
            "op": "+",
            "right": {
              "base": 10,
              "id": 22,
              "kind": "number",
              "loc": 4,
              "value": 4n,
            },
          },
          "id": 24,
          "kind": "statement_augmentedassign",
          "loc": a += b + 4;,
          "op": "+",
          "path": {
            "id": 20,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 26,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 27,
          "kind": "statement_augmentedassign",
          "loc": b -= 1;,
          "op": "-",
          "path": {
            "id": 25,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 29,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 30,
          "kind": "statement_augmentedassign",
          "loc": a -= b;,
          "op": "-",
          "path": {
            "id": 28,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 34,
            "kind": "op_binary",
            "left": {
              "id": 32,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b - 1,
            "op": "-",
            "right": {
              "base": 10,
              "id": 33,
              "kind": "number",
              "loc": 1,
              "value": 1n,
            },
          },
          "id": 35,
          "kind": "statement_augmentedassign",
          "loc": a -= b - 1;,
          "op": "-",
          "path": {
            "id": 31,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 37,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 38,
          "kind": "statement_augmentedassign",
          "loc": b *= 2;,
          "op": "*",
          "path": {
            "id": 36,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 40,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 41,
          "kind": "statement_augmentedassign",
          "loc": a *= b;,
          "op": "*",
          "path": {
            "id": 39,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 45,
            "kind": "op_binary",
            "left": {
              "id": 43,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b * 2,
            "op": "*",
            "right": {
              "base": 10,
              "id": 44,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
          },
          "id": 46,
          "kind": "statement_augmentedassign",
          "loc": a *= b * 2;,
          "op": "*",
          "path": {
            "id": 42,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 48,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 49,
          "kind": "statement_augmentedassign",
          "loc": b /= 2;,
          "op": "/",
          "path": {
            "id": 47,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 51,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 52,
          "kind": "statement_augmentedassign",
          "loc": a /= b;,
          "op": "/",
          "path": {
            "id": 50,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 56,
            "kind": "op_binary",
            "left": {
              "id": 54,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b / 2,
            "op": "/",
            "right": {
              "base": 10,
              "id": 55,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
          },
          "id": 57,
          "kind": "statement_augmentedassign",
          "loc": a /= b / 2;,
          "op": "/",
          "path": {
            "id": 53,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 59,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 60,
          "kind": "statement_augmentedassign",
          "loc": a %= 2;,
          "op": "%",
          "path": {
            "id": 58,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 62,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 63,
          "kind": "statement_augmentedassign",
          "loc": a %= b;,
          "op": "%",
          "path": {
            "id": 61,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 67,
            "kind": "op_binary",
            "left": {
              "id": 65,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b % 2,
            "op": "%",
            "right": {
              "base": 10,
              "id": 66,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
          },
          "id": 68,
          "kind": "statement_augmentedassign",
          "loc": a %= b % 2;,
          "op": "%",
          "path": {
            "id": 64,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 70,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 71,
          "kind": "statement_augmentedassign",
          "loc": a <<= 2;,
          "op": "<<",
          "path": {
            "id": 69,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 73,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 74,
          "kind": "statement_augmentedassign",
          "loc": a <<= b;,
          "op": "<<",
          "path": {
            "id": 72,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 78,
            "kind": "op_binary",
            "left": {
              "id": 76,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b << 2,
            "op": "<<",
            "right": {
              "base": 10,
              "id": 77,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
          },
          "id": 79,
          "kind": "statement_augmentedassign",
          "loc": a <<= b << 2;,
          "op": "<<",
          "path": {
            "id": 75,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 81,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 82,
          "kind": "statement_augmentedassign",
          "loc": a >>= 2;,
          "op": ">>",
          "path": {
            "id": 80,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 84,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 85,
          "kind": "statement_augmentedassign",
          "loc": a >>= b;,
          "op": ">>",
          "path": {
            "id": 83,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 89,
            "kind": "op_binary",
            "left": {
              "id": 87,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b >> 2,
            "op": ">>",
            "right": {
              "base": 10,
              "id": 88,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
          },
          "id": 90,
          "kind": "statement_augmentedassign",
          "loc": a >>= b >> 2;,
          "op": ">>",
          "path": {
            "id": 86,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 91,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 92,
          "kind": "statement_return",
          "loc": return a;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-augmented-assign-bitwise 1`] = `
{
  "id": 56,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 55,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    let a: Int = 1;
    let b: Int = 2;
    a |= b;
    b |= a;
    a |= 3;
    a |= b | 4;
    b &= 1;
    a &= b;
    b &= a;
    a &= b & 1;
    b ^= 2;
    a ^= b;
    b ^= a;
    a ^= b ^ 2;
    return a;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 5,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 6,
          "kind": "statement_let",
          "loc": let a: Int = 1;,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 9,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 10,
          "kind": "statement_let",
          "loc": let b: Int = 2;,
          "name": {
            "id": 7,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "expression": {
            "id": 12,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 13,
          "kind": "statement_augmentedassign",
          "loc": a |= b;,
          "op": "|",
          "path": {
            "id": 11,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 15,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 16,
          "kind": "statement_augmentedassign",
          "loc": b |= a;,
          "op": "|",
          "path": {
            "id": 14,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 18,
            "kind": "number",
            "loc": 3,
            "value": 3n,
          },
          "id": 19,
          "kind": "statement_augmentedassign",
          "loc": a |= 3;,
          "op": "|",
          "path": {
            "id": 17,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 23,
            "kind": "op_binary",
            "left": {
              "id": 21,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b | 4,
            "op": "|",
            "right": {
              "base": 10,
              "id": 22,
              "kind": "number",
              "loc": 4,
              "value": 4n,
            },
          },
          "id": 24,
          "kind": "statement_augmentedassign",
          "loc": a |= b | 4;,
          "op": "|",
          "path": {
            "id": 20,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 26,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 27,
          "kind": "statement_augmentedassign",
          "loc": b &= 1;,
          "op": "&",
          "path": {
            "id": 25,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 29,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 30,
          "kind": "statement_augmentedassign",
          "loc": a &= b;,
          "op": "&",
          "path": {
            "id": 28,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 32,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 33,
          "kind": "statement_augmentedassign",
          "loc": b &= a;,
          "op": "&",
          "path": {
            "id": 31,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 37,
            "kind": "op_binary",
            "left": {
              "id": 35,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b & 1,
            "op": "&",
            "right": {
              "base": 10,
              "id": 36,
              "kind": "number",
              "loc": 1,
              "value": 1n,
            },
          },
          "id": 38,
          "kind": "statement_augmentedassign",
          "loc": a &= b & 1;,
          "op": "&",
          "path": {
            "id": 34,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "base": 10,
            "id": 40,
            "kind": "number",
            "loc": 2,
            "value": 2n,
          },
          "id": 41,
          "kind": "statement_augmentedassign",
          "loc": b ^= 2;,
          "op": "^",
          "path": {
            "id": 39,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 43,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 44,
          "kind": "statement_augmentedassign",
          "loc": a ^= b;,
          "op": "^",
          "path": {
            "id": 42,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 46,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 47,
          "kind": "statement_augmentedassign",
          "loc": b ^= a;,
          "op": "^",
          "path": {
            "id": 45,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
        },
        {
          "expression": {
            "id": 51,
            "kind": "op_binary",
            "left": {
              "id": 49,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b ^ 2,
            "op": "^",
            "right": {
              "base": 10,
              "id": 50,
              "kind": "number",
              "loc": 2,
              "value": 2n,
            },
          },
          "id": 52,
          "kind": "statement_augmentedassign",
          "loc": a ^= b ^ 2;,
          "op": "^",
          "path": {
            "id": 48,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 53,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 54,
          "kind": "statement_return",
          "loc": return a;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-augmented-assign-logic 1`] = `
{
  "id": 36,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 35,
      "kind": "function_def",
      "loc": fun testFunc(): Bool {
    let a: Bool = true;
    let b: Bool = false;
    a ||= true;
    a ||= b;
    a ||= b || true;
    a &&= true;
    a &&= b;
    a &&= b && true;
    return a;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Bool,
        "text": "Bool",
      },
      "statements": [
        {
          "expression": {
            "id": 5,
            "kind": "boolean",
            "loc": true,
            "value": true,
          },
          "id": 6,
          "kind": "statement_let",
          "loc": let a: Bool = true;,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 4,
            "kind": "type_id",
            "loc": Bool,
            "text": "Bool",
          },
        },
        {
          "expression": {
            "id": 9,
            "kind": "boolean",
            "loc": false,
            "value": false,
          },
          "id": 10,
          "kind": "statement_let",
          "loc": let b: Bool = false;,
          "name": {
            "id": 7,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 8,
            "kind": "type_id",
            "loc": Bool,
            "text": "Bool",
          },
        },
        {
          "expression": {
            "id": 12,
            "kind": "boolean",
            "loc": true,
            "value": true,
          },
          "id": 13,
          "kind": "statement_augmentedassign",
          "loc": a ||= true;,
          "op": "||",
          "path": {
            "id": 11,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 15,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 16,
          "kind": "statement_augmentedassign",
          "loc": a ||= b;,
          "op": "||",
          "path": {
            "id": 14,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 20,
            "kind": "op_binary",
            "left": {
              "id": 18,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b || true,
            "op": "||",
            "right": {
              "id": 19,
              "kind": "boolean",
              "loc": true,
              "value": true,
            },
          },
          "id": 21,
          "kind": "statement_augmentedassign",
          "loc": a ||= b || true;,
          "op": "||",
          "path": {
            "id": 17,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 23,
            "kind": "boolean",
            "loc": true,
            "value": true,
          },
          "id": 24,
          "kind": "statement_augmentedassign",
          "loc": a &&= true;,
          "op": "&&",
          "path": {
            "id": 22,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 26,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "id": 27,
          "kind": "statement_augmentedassign",
          "loc": a &&= b;,
          "op": "&&",
          "path": {
            "id": 25,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 31,
            "kind": "op_binary",
            "left": {
              "id": 29,
              "kind": "id",
              "loc": b,
              "text": "b",
            },
            "loc": b && true,
            "op": "&&",
            "right": {
              "id": 30,
              "kind": "boolean",
              "loc": true,
              "value": true,
            },
          },
          "id": 32,
          "kind": "statement_augmentedassign",
          "loc": a &&= b && true;,
          "op": "&&",
          "path": {
            "id": 28,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
        },
        {
          "expression": {
            "id": 33,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "id": 34,
          "kind": "statement_return",
          "loc": return a;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-destructuring 1`] = `
{
  "id": 140,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 4,
          "initializer": null,
          "kind": "field_decl",
          "loc": a: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 7,
          "initializer": null,
          "kind": "field_decl",
          "loc": b: Int,
          "name": {
            "id": 5,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 6,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 10,
          "initializer": null,
          "kind": "field_decl",
          "loc": c: Int,
          "name": {
            "id": 8,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 9,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 11,
      "kind": "struct_decl",
      "loc": struct S {
    a: Int;
    b: Int;
    c: Int;
},
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": S,
        "text": "S",
      },
    },
    {
      "fields": [
        {
          "as": null,
          "id": 15,
          "initializer": null,
          "kind": "field_decl",
          "loc": a: Int,
          "name": {
            "id": 13,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 14,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 18,
          "initializer": null,
          "kind": "field_decl",
          "loc": b: Int,
          "name": {
            "id": 16,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 17,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 19,
      "kind": "message_decl",
      "loc": message M {
    a: Int;
    b: Int;
},
      "name": {
        "id": 12,
        "kind": "type_id",
        "loc": M,
        "text": "M",
      },
      "opcode": null,
    },
    {
      "attributes": [],
      "id": 139,
      "kind": "function_def",
      "loc": fun testFunc(): Int {
    let s = S{ a: 1, b: 2, c: 3 };
    let S { a, b, c } = s;
    let S { a: a1 } = s;
    let S { b: b1 } = s;
    let S { c: c1 } = s;
    let S { a: a2, b: b2 } = s;
    let S { a: a3, c: c3 } = s;
    let S { b: b4, c: c4 } = s;

    let m = M{ a: 1, b: 2 };
    let M { a: a_m, b: b_m } = m;

    return a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4 + a_m + b_m;
},
      "name": {
        "id": 20,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [],
      "return": {
        "id": 21,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "args": [
              {
                "field": {
                  "id": 24,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "id": 26,
                "initializer": {
                  "base": 10,
                  "id": 25,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "kind": "struct_field_initializer",
                "loc": a: 1,
              },
              {
                "field": {
                  "id": 27,
                  "kind": "id",
                  "loc": b,
                  "text": "b",
                },
                "id": 29,
                "initializer": {
                  "base": 10,
                  "id": 28,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
                "kind": "struct_field_initializer",
                "loc": b: 2,
              },
              {
                "field": {
                  "id": 30,
                  "kind": "id",
                  "loc": c,
                  "text": "c",
                },
                "id": 32,
                "initializer": {
                  "base": 10,
                  "id": 31,
                  "kind": "number",
                  "loc": 3,
                  "value": 3n,
                },
                "kind": "struct_field_initializer",
                "loc": c: 3,
              },
            ],
            "id": 33,
            "kind": "struct_instance",
            "loc": S{ a: 1, b: 2, c: 3 },
            "type": {
              "id": 23,
              "kind": "type_id",
              "loc": S,
              "text": "S",
            },
          },
          "id": 34,
          "kind": "statement_let",
          "loc": let s = S{ a: 1, b: 2, c: 3 };,
          "name": {
            "id": 22,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "type": null,
        },
        {
          "expression": {
            "id": 45,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 46,
          "identifiers": Map {
            "a" => [
              {
                "id": 36,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 37,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
            ],
            "b" => [
              {
                "id": 39,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              {
                "id": 40,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
            ],
            "c" => [
              {
                "id": 42,
                "kind": "id",
                "loc": c,
                "text": "c",
              },
              {
                "id": 43,
                "kind": "id",
                "loc": c,
                "text": "c",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { a, b, c } = s;,
          "type": {
            "id": 35,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "id": 51,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 52,
          "identifiers": Map {
            "a" => [
              {
                "id": 48,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 49,
                "kind": "id",
                "loc": a1,
                "text": "a1",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { a: a1 } = s;,
          "type": {
            "id": 47,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "id": 57,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 58,
          "identifiers": Map {
            "b" => [
              {
                "id": 54,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              {
                "id": 55,
                "kind": "id",
                "loc": b1,
                "text": "b1",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { b: b1 } = s;,
          "type": {
            "id": 53,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "id": 63,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 64,
          "identifiers": Map {
            "c" => [
              {
                "id": 60,
                "kind": "id",
                "loc": c,
                "text": "c",
              },
              {
                "id": 61,
                "kind": "id",
                "loc": c1,
                "text": "c1",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { c: c1 } = s;,
          "type": {
            "id": 59,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "id": 72,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 73,
          "identifiers": Map {
            "a" => [
              {
                "id": 66,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 67,
                "kind": "id",
                "loc": a2,
                "text": "a2",
              },
            ],
            "b" => [
              {
                "id": 69,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              {
                "id": 70,
                "kind": "id",
                "loc": b2,
                "text": "b2",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { a: a2, b: b2 } = s;,
          "type": {
            "id": 65,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "id": 81,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 82,
          "identifiers": Map {
            "a" => [
              {
                "id": 75,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 76,
                "kind": "id",
                "loc": a3,
                "text": "a3",
              },
            ],
            "c" => [
              {
                "id": 78,
                "kind": "id",
                "loc": c,
                "text": "c",
              },
              {
                "id": 79,
                "kind": "id",
                "loc": c3,
                "text": "c3",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { a: a3, c: c3 } = s;,
          "type": {
            "id": 74,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "id": 90,
            "kind": "id",
            "loc": s,
            "text": "s",
          },
          "id": 91,
          "identifiers": Map {
            "b" => [
              {
                "id": 84,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              {
                "id": 85,
                "kind": "id",
                "loc": b4,
                "text": "b4",
              },
            ],
            "c" => [
              {
                "id": 87,
                "kind": "id",
                "loc": c,
                "text": "c",
              },
              {
                "id": 88,
                "kind": "id",
                "loc": c4,
                "text": "c4",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let S { b: b4, c: c4 } = s;,
          "type": {
            "id": 83,
            "kind": "type_id",
            "loc": S,
            "text": "S",
          },
        },
        {
          "expression": {
            "args": [
              {
                "field": {
                  "id": 94,
                  "kind": "id",
                  "loc": a,
                  "text": "a",
                },
                "id": 96,
                "initializer": {
                  "base": 10,
                  "id": 95,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "kind": "struct_field_initializer",
                "loc": a: 1,
              },
              {
                "field": {
                  "id": 97,
                  "kind": "id",
                  "loc": b,
                  "text": "b",
                },
                "id": 99,
                "initializer": {
                  "base": 10,
                  "id": 98,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
                "kind": "struct_field_initializer",
                "loc": b: 2,
              },
            ],
            "id": 100,
            "kind": "struct_instance",
            "loc": M{ a: 1, b: 2 },
            "type": {
              "id": 93,
              "kind": "type_id",
              "loc": M,
              "text": "M",
            },
          },
          "id": 101,
          "kind": "statement_let",
          "loc": let m = M{ a: 1, b: 2 };,
          "name": {
            "id": 92,
            "kind": "id",
            "loc": m,
            "text": "m",
          },
          "type": null,
        },
        {
          "expression": {
            "id": 109,
            "kind": "id",
            "loc": m,
            "text": "m",
          },
          "id": 110,
          "identifiers": Map {
            "a" => [
              {
                "id": 103,
                "kind": "id",
                "loc": a,
                "text": "a",
              },
              {
                "id": 104,
                "kind": "id",
                "loc": a_m,
                "text": "a_m",
              },
            ],
            "b" => [
              {
                "id": 106,
                "kind": "id",
                "loc": b,
                "text": "b",
              },
              {
                "id": 107,
                "kind": "id",
                "loc": b_m,
                "text": "b_m",
              },
            ],
          },
          "kind": "statement_destruct",
          "loc": let M { a: a_m, b: b_m } = m;,
          "type": {
            "id": 102,
            "kind": "type_id",
            "loc": M,
            "text": "M",
          },
        },
        {
          "expression": {
            "id": 137,
            "kind": "op_binary",
            "left": {
              "id": 135,
              "kind": "op_binary",
              "left": {
                "id": 133,
                "kind": "op_binary",
                "left": {
                  "id": 131,
                  "kind": "op_binary",
                  "left": {
                    "id": 129,
                    "kind": "op_binary",
                    "left": {
                      "id": 127,
                      "kind": "op_binary",
                      "left": {
                        "id": 125,
                        "kind": "op_binary",
                        "left": {
                          "id": 123,
                          "kind": "op_binary",
                          "left": {
                            "id": 121,
                            "kind": "op_binary",
                            "left": {
                              "id": 119,
                              "kind": "op_binary",
                              "left": {
                                "id": 117,
                                "kind": "op_binary",
                                "left": {
                                  "id": 115,
                                  "kind": "op_binary",
                                  "left": {
                                    "id": 113,
                                    "kind": "op_binary",
                                    "left": {
                                      "id": 111,
                                      "kind": "id",
                                      "loc": a,
                                      "text": "a",
                                    },
                                    "loc": a + b,
                                    "op": "+",
                                    "right": {
                                      "id": 112,
                                      "kind": "id",
                                      "loc": b,
                                      "text": "b",
                                    },
                                  },
                                  "loc": a + b + c,
                                  "op": "+",
                                  "right": {
                                    "id": 114,
                                    "kind": "id",
                                    "loc": c,
                                    "text": "c",
                                  },
                                },
                                "loc": a + b + c + a1,
                                "op": "+",
                                "right": {
                                  "id": 116,
                                  "kind": "id",
                                  "loc": a1,
                                  "text": "a1",
                                },
                              },
                              "loc": a + b + c + a1 + b1,
                              "op": "+",
                              "right": {
                                "id": 118,
                                "kind": "id",
                                "loc": b1,
                                "text": "b1",
                              },
                            },
                            "loc": a + b + c + a1 + b1 + c1,
                            "op": "+",
                            "right": {
                              "id": 120,
                              "kind": "id",
                              "loc": c1,
                              "text": "c1",
                            },
                          },
                          "loc": a + b + c + a1 + b1 + c1 + a2,
                          "op": "+",
                          "right": {
                            "id": 122,
                            "kind": "id",
                            "loc": a2,
                            "text": "a2",
                          },
                        },
                        "loc": a + b + c + a1 + b1 + c1 + a2 + b2,
                        "op": "+",
                        "right": {
                          "id": 124,
                          "kind": "id",
                          "loc": b2,
                          "text": "b2",
                        },
                      },
                      "loc": a + b + c + a1 + b1 + c1 + a2 + b2 + a3,
                      "op": "+",
                      "right": {
                        "id": 126,
                        "kind": "id",
                        "loc": a3,
                        "text": "a3",
                      },
                    },
                    "loc": a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3,
                    "op": "+",
                    "right": {
                      "id": 128,
                      "kind": "id",
                      "loc": c3,
                      "text": "c3",
                    },
                  },
                  "loc": a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4,
                  "op": "+",
                  "right": {
                    "id": 130,
                    "kind": "id",
                    "loc": b4,
                    "text": "b4",
                  },
                },
                "loc": a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4,
                "op": "+",
                "right": {
                  "id": 132,
                  "kind": "id",
                  "loc": c4,
                  "text": "c4",
                },
              },
              "loc": a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4 + a_m,
              "op": "+",
              "right": {
                "id": 134,
                "kind": "id",
                "loc": a_m,
                "text": "a_m",
              },
            },
            "loc": a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4 + a_m + b_m,
            "op": "+",
            "right": {
              "id": 136,
              "kind": "id",
              "loc": b_m,
              "text": "b_m",
            },
          },
          "id": 138,
          "kind": "statement_return",
          "loc": return a + b + c + a1 + b1 + c1 + a2 + b2 + a3 + c3 + b4 + c4 + a_m + b_m;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-if 1`] = `
{
  "id": 16,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 15,
      "kind": "function_def",
      "loc": fun testFunc(src: Int?): Int {
    if (src != null) {
        return src;
    }
    return 0;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 6,
          "kind": "typed_parameter",
          "loc": src: Int?,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": src,
            "text": "src",
          },
          "type": {
            "id": 5,
            "kind": "optional_type",
            "loc": Int?,
            "typeArg": {
              "id": 4,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "condition": {
            "id": 9,
            "kind": "op_binary",
            "left": {
              "id": 7,
              "kind": "id",
              "loc": src,
              "text": "src",
            },
            "loc": src != null,
            "op": "!=",
            "right": {
              "id": 8,
              "kind": "null",
              "loc": null,
            },
          },
          "elseif": null,
          "falseStatements": null,
          "id": 12,
          "kind": "statement_condition",
          "loc": if (src != null) {
        return src;
    },
          "trueStatements": [
            {
              "expression": {
                "id": 10,
                "kind": "id",
                "loc": src,
                "text": "src",
              },
              "id": 11,
              "kind": "statement_return",
              "loc": return src;,
            },
          ],
        },
        {
          "expression": {
            "base": 10,
            "id": 13,
            "kind": "number",
            "loc": 0,
            "value": 0n,
          },
          "id": 14,
          "kind": "statement_return",
          "loc": return 0;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-if-else 1`] = `
{
  "id": 16,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 15,
      "kind": "function_def",
      "loc": fun testFunc(src: Int?): Int {
    if (src != null) {
        return src;
    } else {
        return 10;
    }
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 6,
          "kind": "typed_parameter",
          "loc": src: Int?,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": src,
            "text": "src",
          },
          "type": {
            "id": 5,
            "kind": "optional_type",
            "loc": Int?,
            "typeArg": {
              "id": 4,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "condition": {
            "id": 9,
            "kind": "op_binary",
            "left": {
              "id": 7,
              "kind": "id",
              "loc": src,
              "text": "src",
            },
            "loc": src != null,
            "op": "!=",
            "right": {
              "id": 8,
              "kind": "null",
              "loc": null,
            },
          },
          "elseif": null,
          "falseStatements": [
            {
              "expression": {
                "base": 10,
                "id": 12,
                "kind": "number",
                "loc": 10,
                "value": 10n,
              },
              "id": 13,
              "kind": "statement_return",
              "loc": return 10;,
            },
          ],
          "id": 14,
          "kind": "statement_condition",
          "loc": if (src != null) {
        return src;
    } else {
        return 10;
    },
          "trueStatements": [
            {
              "expression": {
                "id": 10,
                "kind": "id",
                "loc": src,
                "text": "src",
              },
              "id": 11,
              "kind": "statement_return",
              "loc": return src;,
            },
          ],
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-optional-semicolon-for-last-statement 1`] = `
{
  "id": 40,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 20,
      "kind": "function_def",
      "loc": fun test1() {
    let i: Int = 1;
    while(i >= 10 || i <= 100) { i += 1 }
    let i = 42
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": test1,
        "text": "test1",
      },
      "params": [],
      "return": null,
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 4,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 5,
          "kind": "statement_let",
          "loc": let i: Int = 1;,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": i,
            "text": "i",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "condition": {
            "id": 12,
            "kind": "op_binary",
            "left": {
              "id": 8,
              "kind": "op_binary",
              "left": {
                "id": 6,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
              "loc": i >= 10,
              "op": ">=",
              "right": {
                "base": 10,
                "id": 7,
                "kind": "number",
                "loc": 10,
                "value": 10n,
              },
            },
            "loc": i >= 10 || i <= 100,
            "op": "||",
            "right": {
              "id": 11,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
              "loc": i <= 100,
              "op": "<=",
              "right": {
                "base": 10,
                "id": 10,
                "kind": "number",
                "loc": 100,
                "value": 100n,
              },
            },
          },
          "id": 16,
          "kind": "statement_while",
          "loc": while(i >= 10 || i <= 100) { i += 1 },
          "statements": [
            {
              "expression": {
                "base": 10,
                "id": 14,
                "kind": "number",
                "loc": 1,
                "value": 1n,
              },
              "id": 15,
              "kind": "statement_augmentedassign",
              "loc": i += 1,
              "op": "+",
              "path": {
                "id": 13,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
            },
          ],
        },
        {
          "expression": {
            "base": 10,
            "id": 18,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "id": 19,
          "kind": "statement_let",
          "loc": let i = 42,
          "name": {
            "id": 17,
            "kind": "id",
            "loc": i,
            "text": "i",
          },
          "type": null,
        },
      ],
    },
    {
      "attributes": [],
      "id": 23,
      "kind": "function_def",
      "loc": fun test2() { return },
      "name": {
        "id": 21,
        "kind": "id",
        "loc": test2,
        "text": "test2",
      },
      "params": [],
      "return": null,
      "statements": [
        {
          "expression": null,
          "id": 22,
          "kind": "statement_return",
          "loc": return,
        },
      ],
    },
    {
      "attributes": [],
      "id": 28,
      "kind": "function_def",
      "loc": fun test3(): Int { return 42 },
      "name": {
        "id": 24,
        "kind": "id",
        "loc": test3,
        "text": "test3",
      },
      "params": [],
      "return": {
        "id": 25,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 26,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "id": 27,
          "kind": "statement_return",
          "loc": return 42,
        },
      ],
    },
    {
      "attributes": [],
      "id": 39,
      "kind": "function_def",
      "loc": fun test4(): Int {
    do { 21 + 21 } until (true && true)
},
      "name": {
        "id": 29,
        "kind": "id",
        "loc": test4,
        "text": "test4",
      },
      "params": [],
      "return": {
        "id": 30,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "condition": {
            "id": 33,
            "kind": "op_binary",
            "left": {
              "id": 31,
              "kind": "boolean",
              "loc": true,
              "value": true,
            },
            "loc": true && true,
            "op": "&&",
            "right": {
              "id": 32,
              "kind": "boolean",
              "loc": true,
              "value": true,
            },
          },
          "id": 38,
          "kind": "statement_until",
          "loc": do { 21 + 21 } until (true && true),
          "statements": [
            {
              "expression": {
                "id": 36,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 34,
                  "kind": "number",
                  "loc": 21,
                  "value": 21n,
                },
                "loc": 21 + 21,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 35,
                  "kind": "number",
                  "loc": 21,
                  "value": 21n,
                },
              },
              "id": 37,
              "kind": "statement_expression",
              "loc": 21 + 21,
            },
          ],
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-while-loop 1`] = `
{
  "id": 20,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 19,
      "kind": "function_def",
      "loc": fun main() {
    let i: Int = 1;
    while(i >= 10 || i <= 100) {
        i = i + 1;
    }
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": main,
        "text": "main",
      },
      "params": [],
      "return": null,
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 4,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 5,
          "kind": "statement_let",
          "loc": let i: Int = 1;,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": i,
            "text": "i",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "condition": {
            "id": 12,
            "kind": "op_binary",
            "left": {
              "id": 8,
              "kind": "op_binary",
              "left": {
                "id": 6,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
              "loc": i >= 10,
              "op": ">=",
              "right": {
                "base": 10,
                "id": 7,
                "kind": "number",
                "loc": 10,
                "value": 10n,
              },
            },
            "loc": i >= 10 || i <= 100,
            "op": "||",
            "right": {
              "id": 11,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
              "loc": i <= 100,
              "op": "<=",
              "right": {
                "base": 10,
                "id": 10,
                "kind": "number",
                "loc": 100,
                "value": 100n,
              },
            },
          },
          "id": 18,
          "kind": "statement_while",
          "loc": while(i >= 10 || i <= 100) {
        i = i + 1;
    },
          "statements": [
            {
              "expression": {
                "id": 16,
                "kind": "op_binary",
                "left": {
                  "id": 14,
                  "kind": "id",
                  "loc": i,
                  "text": "i",
                },
                "loc": i + 1,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 15,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
              },
              "id": 17,
              "kind": "statement_assign",
              "loc": i = i + 1;,
              "path": {
                "id": 13,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
            },
          ],
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse stmt-while-repeat-do-loops 1`] = `
{
  "id": 28,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 27,
      "kind": "function_def",
      "loc": fun main() {
    let i: Int = 1;
    while(true) {
        i = i + 1;
    }
    repeat(10) {
        i = i * 10;
    }
    do {
        i = i - 1;
    } until(false);
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": main,
        "text": "main",
      },
      "params": [],
      "return": null,
      "statements": [
        {
          "expression": {
            "base": 10,
            "id": 4,
            "kind": "number",
            "loc": 1,
            "value": 1n,
          },
          "id": 5,
          "kind": "statement_let",
          "loc": let i: Int = 1;,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": i,
            "text": "i",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "condition": {
            "id": 6,
            "kind": "boolean",
            "loc": true,
            "value": true,
          },
          "id": 12,
          "kind": "statement_while",
          "loc": while(true) {
        i = i + 1;
    },
          "statements": [
            {
              "expression": {
                "id": 10,
                "kind": "op_binary",
                "left": {
                  "id": 8,
                  "kind": "id",
                  "loc": i,
                  "text": "i",
                },
                "loc": i + 1,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 9,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
              },
              "id": 11,
              "kind": "statement_assign",
              "loc": i = i + 1;,
              "path": {
                "id": 7,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
            },
          ],
        },
        {
          "id": 19,
          "iterations": {
            "base": 10,
            "id": 13,
            "kind": "number",
            "loc": 10,
            "value": 10n,
          },
          "kind": "statement_repeat",
          "loc": repeat(10) {
        i = i * 10;
    },
          "statements": [
            {
              "expression": {
                "id": 17,
                "kind": "op_binary",
                "left": {
                  "id": 15,
                  "kind": "id",
                  "loc": i,
                  "text": "i",
                },
                "loc": i * 10,
                "op": "*",
                "right": {
                  "base": 10,
                  "id": 16,
                  "kind": "number",
                  "loc": 10,
                  "value": 10n,
                },
              },
              "id": 18,
              "kind": "statement_assign",
              "loc": i = i * 10;,
              "path": {
                "id": 14,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
            },
          ],
        },
        {
          "condition": {
            "id": 20,
            "kind": "boolean",
            "loc": false,
            "value": false,
          },
          "id": 26,
          "kind": "statement_until",
          "loc": do {
        i = i - 1;
    } until(false);,
          "statements": [
            {
              "expression": {
                "id": 24,
                "kind": "op_binary",
                "left": {
                  "id": 22,
                  "kind": "id",
                  "loc": i,
                  "text": "i",
                },
                "loc": i - 1,
                "op": "-",
                "right": {
                  "base": 10,
                  "id": 23,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
              },
              "id": 25,
              "kind": "statement_assign",
              "loc": i = i - 1;,
              "path": {
                "id": 21,
                "kind": "id",
                "loc": i,
                "text": "i",
              },
            },
          ],
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse struct-field-punning 1`] = `
{
  "id": 28,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 4,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 7,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 5,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 6,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 8,
      "kind": "struct_decl",
      "loc": struct A {
    x: Int;
    y: Int;
},
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "attributes": [],
      "id": 12,
      "initializer": {
        "base": 10,
        "id": 11,
        "kind": "number",
        "loc": 5,
        "value": 5n,
      },
      "kind": "constant_def",
      "loc": const x: Int = 5;,
      "name": {
        "id": 9,
        "kind": "id",
        "loc": x,
        "text": "x",
      },
      "type": {
        "id": 10,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
    },
    {
      "attributes": [],
      "id": 16,
      "initializer": {
        "base": 10,
        "id": 15,
        "kind": "number",
        "loc": 6,
        "value": 6n,
      },
      "kind": "constant_def",
      "loc": const y: Int = 6;,
      "name": {
        "id": 13,
        "kind": "id",
        "loc": y,
        "text": "y",
      },
      "type": {
        "id": 14,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
    },
    {
      "attributes": [],
      "id": 27,
      "initializer": {
        "args": [
          {
            "field": {
              "id": 20,
              "kind": "id",
              "loc": x,
              "text": "x",
            },
            "id": 22,
            "initializer": {
              "id": 21,
              "kind": "id",
              "loc": x,
              "text": "x",
            },
            "kind": "struct_field_initializer",
            "loc": x,
          },
          {
            "field": {
              "id": 23,
              "kind": "id",
              "loc": y,
              "text": "y",
            },
            "id": 25,
            "initializer": {
              "id": 24,
              "kind": "id",
              "loc": y,
              "text": "y",
            },
            "kind": "struct_field_initializer",
            "loc": y,
          },
        ],
        "id": 26,
        "kind": "struct_instance",
        "loc": A { x, y },
        "type": {
          "id": 19,
          "kind": "type_id",
          "loc": A,
          "text": "A",
        },
      },
      "kind": "constant_def",
      "loc": const D: A = A { x, y };,
      "name": {
        "id": 17,
        "kind": "id",
        "loc": D,
        "text": "D",
      },
      "type": {
        "id": 18,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse struct-msg-as 1`] = `
{
  "id": 12,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 4,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 5,
      "kind": "struct_decl",
      "loc": struct A {
    x: Int;
},
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "fields": [
        {
          "as": {
            "id": 9,
            "kind": "id",
            "loc": coin,
            "text": "coin",
          },
          "id": 10,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int as coin,
          "name": {
            "id": 7,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 11,
      "kind": "message_decl",
      "loc": message B {
    x: Int as coin;
},
      "name": {
        "id": 6,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
      "opcode": null,
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse struct-msg-initializers 1`] = `
{
  "id": 18,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 5,
          "initializer": {
            "base": 10,
            "id": 4,
            "kind": "number",
            "loc": 1000,
            "value": 1000n,
          },
          "kind": "field_decl",
          "loc": x: Int = 1000,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 6,
      "kind": "struct_decl",
      "loc": struct A {
    x: Int = 1000;
},
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "fields": [
        {
          "as": {
            "id": 10,
            "kind": "id",
            "loc": coins,
            "text": "coins",
          },
          "id": 12,
          "initializer": {
            "base": 10,
            "id": 11,
            "kind": "number",
            "loc": 1000,
            "value": 1000n,
          },
          "kind": "field_decl",
          "loc": x: Int as coins = 1000,
          "name": {
            "id": 8,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 9,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 16,
          "initializer": {
            "id": 15,
            "kind": "boolean",
            "loc": true,
            "value": true,
          },
          "kind": "field_decl",
          "loc": y: Bool = true,
          "name": {
            "id": 13,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 14,
            "kind": "type_id",
            "loc": Bool,
            "text": "Bool",
          },
        },
      ],
      "id": 17,
      "kind": "message_decl",
      "loc": message B {
    x: Int as coins = 1000;
    y: Bool = true;
},
      "name": {
        "id": 7,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
      "opcode": null,
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse struct-msg-trailing-semicolon 1`] = `
{
  "id": 63,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 4,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 5,
      "kind": "struct_decl",
      "loc": struct A { x: Int },
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "fields": [
        {
          "as": null,
          "id": 9,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 7,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 8,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 12,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 10,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 11,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 13,
      "kind": "struct_decl",
      "loc": struct B { x: Int; y: Int },
      "name": {
        "id": 6,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
    },
    {
      "fields": [
        {
          "as": null,
          "id": 17,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 15,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 16,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 21,
          "initializer": {
            "base": 10,
            "id": 20,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "kind": "field_decl",
          "loc": y: Int = 42,
          "name": {
            "id": 18,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 19,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 22,
      "kind": "struct_decl",
      "loc": struct C { x: Int; y: Int = 42 },
      "name": {
        "id": 14,
        "kind": "type_id",
        "loc": C,
        "text": "C",
      },
    },
    {
      "fields": [
        {
          "as": null,
          "id": 27,
          "initializer": {
            "base": 10,
            "id": 26,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "kind": "field_decl",
          "loc": x: Int = 42,
          "name": {
            "id": 24,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 25,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 30,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 28,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 29,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 31,
      "kind": "struct_decl",
      "loc": struct D { x: Int = 42; y: Int },
      "name": {
        "id": 23,
        "kind": "type_id",
        "loc": D,
        "text": "D",
      },
    },
    {
      "fields": [
        {
          "as": null,
          "id": 35,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 33,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 34,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 36,
      "kind": "message_decl",
      "loc": message E { x: Int },
      "name": {
        "id": 32,
        "kind": "type_id",
        "loc": E,
        "text": "E",
      },
      "opcode": null,
    },
    {
      "fields": [
        {
          "as": null,
          "id": 40,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 38,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 39,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 43,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 41,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 42,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 44,
      "kind": "message_decl",
      "loc": message F { x: Int; y: Int },
      "name": {
        "id": 37,
        "kind": "type_id",
        "loc": F,
        "text": "F",
      },
      "opcode": null,
    },
    {
      "fields": [
        {
          "as": null,
          "id": 48,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: Int,
          "name": {
            "id": 46,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 47,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 52,
          "initializer": {
            "base": 10,
            "id": 51,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "kind": "field_decl",
          "loc": y: Int = 42,
          "name": {
            "id": 49,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 50,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 53,
      "kind": "message_decl",
      "loc": message G { x: Int; y: Int = 42 },
      "name": {
        "id": 45,
        "kind": "type_id",
        "loc": G,
        "text": "G",
      },
      "opcode": null,
    },
    {
      "fields": [
        {
          "as": null,
          "id": 58,
          "initializer": {
            "base": 10,
            "id": 57,
            "kind": "number",
            "loc": 42,
            "value": 42n,
          },
          "kind": "field_decl",
          "loc": x: Int = 42,
          "name": {
            "id": 55,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 56,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
        {
          "as": null,
          "id": 61,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: Int,
          "name": {
            "id": 59,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 60,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 62,
      "kind": "message_decl",
      "loc": message G { x: Int = 42; y: Int },
      "name": {
        "id": 54,
        "kind": "type_id",
        "loc": G,
        "text": "G",
      },
      "opcode": null,
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse trait-optional-semicolon-for-last-const-decl 1`] = `
{
  "id": 6,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "attributes": [
            {
              "loc": abstract,
              "type": "abstract",
            },
          ],
          "id": 4,
          "kind": "constant_decl",
          "loc": abstract const foo: Int,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": foo,
            "text": "foo",
          },
          "type": {
            "id": 3,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 5,
      "kind": "trait",
      "loc": trait Test { abstract const foo: Int },
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Test,
        "text": "Test",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse trait-optional-semicolon-for-last-fun-decl 1`] = `
{
  "id": 5,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "declarations": [
        {
          "attributes": [
            {
              "kind": "function_attribute",
              "loc": abstract,
              "type": "abstract",
            },
          ],
          "id": 3,
          "kind": "function_decl",
          "loc": abstract fun foo(),
          "name": {
            "id": 2,
            "kind": "id",
            "loc": foo,
            "text": "foo",
          },
          "params": [],
          "return": null,
        },
      ],
      "id": 4,
      "kind": "trait",
      "loc": trait Test { abstract fun foo() },
      "name": {
        "id": 1,
        "kind": "id",
        "loc": Test,
        "text": "Test",
      },
      "traits": [],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse traits-inheritance-trailing-comma 1`] = `
{
  "id": 20,
  "imports": [],
  "items": [
    {
      "id": 2,
      "kind": "primitive_type_decl",
      "loc": primitive Int;,
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 6,
          "initializer": null,
          "kind": "field_decl",
          "loc": c: Int,
          "name": {
            "id": 4,
            "kind": "id",
            "loc": c,
            "text": "c",
          },
          "type": {
            "id": 5,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 7,
      "kind": "trait",
      "loc": trait OtherTrait {
    c: Int;
},
      "name": {
        "id": 3,
        "kind": "id",
        "loc": OtherTrait,
        "text": "OtherTrait",
      },
      "traits": [],
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 11,
          "initializer": null,
          "kind": "field_decl",
          "loc": a: Int,
          "name": {
            "id": 9,
            "kind": "id",
            "loc": a,
            "text": "a",
          },
          "type": {
            "id": 10,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 13,
      "kind": "trait",
      "loc": trait SomeTrait with OtherTrait, {
    a: Int;
},
      "name": {
        "id": 8,
        "kind": "id",
        "loc": SomeTrait,
        "text": "SomeTrait",
      },
      "traits": [
        {
          "id": 12,
          "kind": "id",
          "loc": OtherTrait,
          "text": "OtherTrait",
        },
      ],
    },
    {
      "attributes": [],
      "declarations": [
        {
          "as": null,
          "id": 17,
          "initializer": null,
          "kind": "field_decl",
          "loc": b: Int,
          "name": {
            "id": 15,
            "kind": "id",
            "loc": b,
            "text": "b",
          },
          "type": {
            "id": 16,
            "kind": "type_id",
            "loc": Int,
            "text": "Int",
          },
        },
      ],
      "id": 19,
      "kind": "contract",
      "loc": contract Main with SomeTrait, {
    b: Int;
},
      "name": {
        "id": 14,
        "kind": "id",
        "loc": Main,
        "text": "Main",
      },
      "traits": [
        {
          "id": 18,
          "kind": "id",
          "loc": SomeTrait,
          "text": "SomeTrait",
        },
      ],
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse type-struct-with-map 1`] = `
{
  "id": 15,
  "imports": [],
  "items": [
    {
      "fields": [
        {
          "as": null,
          "id": 6,
          "initializer": null,
          "kind": "field_decl",
          "loc": y: map<Int, Int>,
          "name": {
            "id": 2,
            "kind": "id",
            "loc": y,
            "text": "y",
          },
          "type": {
            "id": 5,
            "keyStorageType": null,
            "keyType": {
              "id": 3,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
            "kind": "map_type",
            "loc": map<Int, Int>,
            "valueStorageType": null,
            "valueType": {
              "id": 4,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "id": 7,
      "kind": "struct_decl",
      "loc": struct A {
    y: map<Int, Int>;
},
      "name": {
        "id": 1,
        "kind": "type_id",
        "loc": A,
        "text": "A",
      },
    },
    {
      "fields": [
        {
          "as": null,
          "id": 13,
          "initializer": null,
          "kind": "field_decl",
          "loc": x: map<Int, Int>,
          "name": {
            "id": 9,
            "kind": "id",
            "loc": x,
            "text": "x",
          },
          "type": {
            "id": 12,
            "keyStorageType": null,
            "keyType": {
              "id": 10,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
            "kind": "map_type",
            "loc": map<Int, Int>,
            "valueStorageType": null,
            "valueType": {
              "id": 11,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "id": 14,
      "kind": "message_decl",
      "loc": message B {
    x: map<Int, Int>;
},
      "name": {
        "id": 8,
        "kind": "type_id",
        "loc": B,
        "text": "B",
      },
      "opcode": null,
    },
  ],
  "kind": "module",
}
`;

exports[`grammar should parse types-optional 1`] = `
{
  "id": 19,
  "imports": [],
  "items": [
    {
      "attributes": [],
      "id": 18,
      "kind": "function_def",
      "loc": fun testFunc(src: Int?): Int {
    return 1 + 2 + (123 + 3)!! > 123;
},
      "name": {
        "id": 1,
        "kind": "id",
        "loc": testFunc,
        "text": "testFunc",
      },
      "params": [
        {
          "id": 6,
          "kind": "typed_parameter",
          "loc": src: Int?,
          "name": {
            "id": 3,
            "kind": "id",
            "loc": src,
            "text": "src",
          },
          "type": {
            "id": 5,
            "kind": "optional_type",
            "loc": Int?,
            "typeArg": {
              "id": 4,
              "kind": "type_id",
              "loc": Int,
              "text": "Int",
            },
          },
        },
      ],
      "return": {
        "id": 2,
        "kind": "type_id",
        "loc": Int,
        "text": "Int",
      },
      "statements": [
        {
          "expression": {
            "id": 16,
            "kind": "op_binary",
            "left": {
              "id": 14,
              "kind": "op_binary",
              "left": {
                "id": 9,
                "kind": "op_binary",
                "left": {
                  "base": 10,
                  "id": 7,
                  "kind": "number",
                  "loc": 1,
                  "value": 1n,
                },
                "loc": 1 + 2,
                "op": "+",
                "right": {
                  "base": 10,
                  "id": 8,
                  "kind": "number",
                  "loc": 2,
                  "value": 2n,
                },
              },
              "loc": 1 + 2 + (123 + 3)!!,
              "op": "+",
              "right": {
                "id": 13,
                "kind": "op_unary",
                "loc": (123 + 3)!!,
                "op": "!!",
                "operand": {
                  "id": 12,
                  "kind": "op_binary",
                  "left": {
                    "base": 10,
                    "id": 10,
                    "kind": "number",
                    "loc": 123,
                    "value": 123n,
                  },
                  "loc": 123 + 3,
                  "op": "+",
                  "right": {
                    "base": 10,
                    "id": 11,
                    "kind": "number",
                    "loc": 3,
                    "value": 3n,
                  },
                },
              },
            },
            "loc": 1 + 2 + (123 + 3)!! > 123,
            "op": ">",
            "right": {
              "base": 10,
              "id": 15,
              "kind": "number",
              "loc": 123,
              "value": 123n,
            },
          },
          "id": 17,
          "kind": "statement_return",
          "loc": return 1 + 2 + (123 + 3)!! > 123;,
        },
      ],
    },
  ],
  "kind": "module",
}
`;