Testing file: ../demo/annotate.vt
    => ✓
AST Tree:
└── PROGRAM (2:2)
    ├── FUNC_DECL (3:5)
        ├── ANNOTATIONS (2:2)
            └── ANNOTATION: Test (2:2)
        ├── IDENTIFIER: testFunction (3:6)
        ├── PARAM_LIST (3:20)
        └── BLOCK (3:22)
    ├── VAR_DECL: let (10:19)
        ├── ANNOTATIONS (8:2)
            ├── ANNOTATION: Author (8:2)
                └── POS_ARG (8:19)
                    └── STRING_LITERAL: John Doe (8:9)
            └── ANNOTATION: Version (9:2)
                └── POS_ARG (9:14)
                    └── FLOAT_LITERAL: 1.35 (9:10)
        ├── IDENTIFIER: projectVersion (10:5)
        └── INT_LITERAL: 4 (10:22)
    ├── VAR_DECL: let (13:18)
        ├── ANNOTATIONS (12:2)
            └── ANNOTATION: Config (12:2)
                ├── NAMED_ARG (12:9)
                    ├── IDENTIFIER: key (12:9)
                    └── STRING_LITERAL: debug_mode (12:13)
                └── NAMED_ARG (12:27)
                    ├── IDENTIFIER: enabled (12:27)
                    └── BOOL_LITERAL: true (12:35)
        ├── IDENTIFIER: debugSettings (13:5)
        └── MAP_LITERAL (13:22)
            ├── MAP_ENTRY (14:13)
                ├── IDENTIFIER: logLevel (14:5)
                └── STRING_LITERAL: verbose (14:15)
            └── MAP_ENTRY (15:12)
                ├── IDENTIFIER: timeout (15:5)
                └── INT_LITERAL: 5000 (15:14)
    ├── FUNC_DECL (20:5)
        ├── ANNOTATIONS (19:2)
            └── ANNOTATION: Deprecated (19:2)
                └── POS_ARG (19:36)
                    └── STRING_LITERAL: Use newMethod instead (19:13)
        ├── IDENTIFIER: oldMethod (20:6)
        ├── PARAM_LIST (20:17)
        └── BLOCK (20:19)
    ├── FUNC_DECL (27:5)
        ├── ANNOTATIONS (25:2)
            ├── ANNOTATION: Metrics (25:2)
                ├── NAMED_ARG (25:10)
                    ├── IDENTIFIER: track (25:10)
                    └── BOOL_LITERAL: true (25:16)
                └── NAMED_ARG (25:22)
                    ├── IDENTIFIER: category (25:22)
                    └── STRING_LITERAL: performance (25:31)
            └── ANNOTATION: Retry (26:2)
                └── NAMED_ARG (26:8)
                    ├── IDENTIFIER: maxAttempts (26:8)
                    └── INT_LITERAL: 3 (26:20)
        ├── IDENTIFIER: networkCall (27:6)
        ├── PARAM_LIST (27:19)
        └── BLOCK (27:21)
    ├── IDENTIFIER: var (33:15)
        └── ANNOTATIONS (32:2)
            └── ANNOTATION: ReadOnly (32:2)
    ├── BINARY_EXPR: = (36:2)
        ├── IDENTIFIER: configData (33:5)
        └── ARRAY_LITERAL (33:19)
            ├── INT_LITERAL: 1 (33:19)
            ├── INT_LITERAL: 2 (33:22)
            └── INT_LITERAL: 3 (33:25)
    └── FUNC_DECL (41:5)
        ├── ANNOTATIONS (36:2)
            └── ANNOTATION: DatabaseConnection (36:2)
                ├── NAMED_ARG (37:5)
                    ├── IDENTIFIER: host (37:5)
                    └── STRING_LITERAL: localhost (37:10)
                ├── NAMED_ARG (38:5)
                    ├── IDENTIFIER: port (38:5)
                    └── INT_LITERAL: 5432 (38:10)
                └── NAMED_ARG (39:5)
                    ├── IDENTIFIER: options (39:5)
                    └── MAP_LITERAL (39:14)
                        ├── MAP_ENTRY (39:17)
                            ├── IDENTIFIER: ssl (39:14)
                            └── BOOL_LITERAL: true (39:19)
                        └── MAP_ENTRY (39:33)
                            ├── IDENTIFIER: poolSize (39:25)
                            └── INT_LITERAL: 5 (39:35)
        ├── IDENTIFIER: connectToDatabase (41:6)
        ├── PARAM_LIST (41:25)
        └── BLOCK (41:27)
Testing file: ../demo/array.vt
    => ✓
AST Tree:
└── PROGRAM (2:4)
    ├── VAR_DECL: let (2:8)
        ├── IDENTIFIER: arr (2:5)
        └── ARRAY_LITERAL (2:12)
            ├── INT_LITERAL: 1 (2:12)
            ├── INT_LITERAL: 2 (2:15)
            ├── INT_LITERAL: 3 (2:18)
            ├── INT_LITERAL: 4 (2:21)
            └── INT_LITERAL: 5 (2:24)
    ├── VAR_DECL: let (3:9)
        ├── IDENTIFIER: arr1 (3:5)
        ├── ARRAY_TYPE: int32 (3:11)
        └── ARRAY_LITERAL (3:22)
            ├── INT_LITERAL: 1 (3:22)
            ├── INT_LITERAL: 2 (3:25)
            ├── INT_LITERAL: 3 (3:28)
            ├── INT_LITERAL: 4 (3:31)
            └── INT_LITERAL: 5 (3:34)
    ├── VAR_DECL: let (4:9)
        ├── IDENTIFIER: arr2 (4:5)
        ├── ARRAY_TYPE: i32 (4:11)
            └── INT_LITERAL: 8 (4:15)
        └── ARRAY_LITERAL (4:21)
            ├── INT_LITERAL: 1 (4:21)
            ├── INT_LITERAL: 2 (4:24)
            ├── INT_LITERAL: 3 (4:27)
            ├── INT_LITERAL: 4 (4:30)
            ├── INT_LITERAL: 5 (4:33)
            ├── INT_LITERAL: 6 (4:35)
            ├── INT_LITERAL: 6 (4:37)
            └── INT_LITERAL: 8 (4:39)
    └── VAR_DECL: let (5:12)
        ├── IDENTIFIER: numbers (5:5)
        ├── TYPE_IDENTIFIER: array (5:14)
        └── ARRAY_LITERAL (5:23)
            ├── INT_LITERAL: 1 (5:23)
            ├── INT_LITERAL: 2 (5:26)
            ├── INT_LITERAL: 3 (5:29)
            ├── INT_LITERAL: 4 (5:32)
            └── INT_LITERAL: 5 (5:35)
Testing file: ../demo/assignment.vt
    => ✓
AST Tree:
└── PROGRAM (1:4)
    ├── VAR_DECL: let (1:6)
        ├── IDENTIFIER: b (1:5)
        ├── TYPE_IDENTIFIER: i32 (1:7)
        └── BINARY_EXPR: + (1:15)
            ├── INT_LITERAL: 6 (1:13)
            └── INT_LITERAL: 5 (1:17)
    └── VAR_DECL: let (3:6)
        ├── IDENTIFIER: c (3:5)
        ├── TYPE_IDENTIFIER: i32 (3:7)
        └── BINARY_EXPR: + (3:22)
            ├── BINARY_EXPR: + (3:19)
                ├── BINARY_EXPR: - (3:15)
                    ├── INT_LITERAL: 1 (3:13)
                    └── INT_LITERAL: 2 (3:17)
                └── INT_LITERAL: 3 (3:20)
            └── BINARY_EXPR: / (3:25)
                ├── INT_LITERAL: 1 (3:24)
                └── INT_LITERAL: 8 (3:26)
Testing file: ../demo/control_stmt.vt
    => ✓
AST Tree:
└── PROGRAM (1:3)
    ├── IF_STMT (1:3)
        ├── BINARY_EXPR: and (1:12)
            ├── BINARY_EXPR: >= (1:7)
                ├── IDENTIFIER: a (1:5)
                └── INT_LITERAL: 6 (1:10)
            └── BINARY_EXPR: <= (1:18)
                ├── IDENTIFIER: a (1:16)
                └── INT_LITERAL: 10 (1:21)
        ├── BLOCK (1:26)
            └── CALL_EXPR (3:2)
                ├── IDENTIFIER: print (2:5)
                └── PARAM_LIST (2:34)
                    └── STRING_LITERAL: a is between 6 and 10 (2:11)
        ├── ELSE_IF (3:12)
            ├── BINARY_EXPR: && (3:20)
                ├── BINARY_EXPR: >= (3:14)
                    ├── IDENTIFIER: a (3:12)
                    └── INT_LITERAL: 11 (3:17)
                └── BINARY_EXPR: <= (3:25)
                    ├── IDENTIFIER: a (3:23)
                    └── INT_LITERAL: 15 (3:28)
            └── BLOCK (3:33)
                └── CALL_EXPR (5:2)
                    ├── IDENTIFIER: print (4:5)
                    └── PARAM_LIST (4:35)
                        └── STRING_LITERAL: a is between 11 and 15 (4:11)
        ├── ELSE_IF (5:12)
            ├── BINARY_EXPR: && (5:20)
                ├── BINARY_EXPR: >= (5:14)
                    ├── IDENTIFIER: a (5:12)
                    └── INT_LITERAL: 16 (5:17)
                └── BINARY_EXPR: <= (5:25)
                    ├── IDENTIFIER: a (5:23)
                    └── INT_LITERAL: 20 (5:28)
            └── BLOCK (5:33)
                └── CALL_EXPR (7:2)
                    ├── IDENTIFIER: print (6:5)
                    └── PARAM_LIST (6:35)
                        └── STRING_LITERAL: a is between 16 and 20 (6:11)
        └── ELSE_BLOCK (7:9)
            └── BLOCK (7:9)
                └── CALL_EXPR (9:2)
                    ├── IDENTIFIER: print (8:5)
                    └── PARAM_LIST (8:38)
                        └── STRING_LITERAL: a is not between 6 and 20 (8:11)
    └── IF_STMT (11:3)
        ├── BINARY_EXPR: or (11:12)
            ├── BINARY_EXPR: == (11:7)
                ├── IDENTIFIER: a (11:5)
                └── INT_LITERAL: 6 (11:10)
            └── BINARY_EXPR: == (11:17)
                ├── IDENTIFIER: a (11:15)
                └── INT_LITERAL: 10 (11:20)
        ├── BLOCK (11:25)
            └── CALL_EXPR (13:2)
                ├── IDENTIFIER: print (12:5)
                └── PARAM_LIST (12:25)
                    └── STRING_LITERAL: a is 6 or 10 (12:11)
        └── ELSE_BLOCK (13:9)
            └── BLOCK (13:9)
                └── CALL_EXPR (15:2)
                    ├── IDENTIFIER: print (14:5)
                    └── PARAM_LIST (14:29)
                        └── STRING_LITERAL: a is not 6 or 10 (14:11)
Testing file: ../demo/float.vt
    => ✓
AST Tree:
└── PROGRAM (1:4)
    ├── VAR_DECL: let (1:6)
        ├── IDENTIFIER: f (1:5)
        └── FLOAT_LITERAL: 6.555 (1:9)
    ├── VAR_DECL: let (2:7)
        ├── IDENTIFIER: f1 (2:5)
        └── FLOAT_LITERAL: 6444848484.5554484897874 (2:10)
    └── VAR_DECL: let (3:7)
        ├── IDENTIFIER: f2 (3:5)
        └── BINARY_EXPR: * (3:51)
            ├── BINARY_EXPR: / (3:45)
                ├── BINARY_EXPR: - (3:41)
                    ├── BINARY_EXPR: * (3:37)
                        ├── BINARY_EXPR: - (3:30)
                            ├── BINARY_EXPR: + (3:22)
                                ├── FLOAT_LITERAL: 58555.48484 (3:10)
                                └── FLOAT_LITERAL: 55.444 (3:23)
                            └── FLOAT_LITERAL: 7.88 (3:32)
                        └── INT_LITERAL: 44 (3:38)
                    └── INT_LITERAL: 4 (3:43)
                └── FLOAT_LITERAL: 9.22 (3:46)
            └── BINARY_EXPR: + (3:58)
                ├── FLOAT_LITERAL: 5.666 (3:53)
                └── INT_LITERAL: 3 (3:59)
Testing file: ../demo/lexer_test.vt
    => ✓
AST Tree:
└── PROGRAM (2:4)
    ├── VAR_DECL: let (2:11)
        ├── IDENTIFIER: binary (2:5)
        └── INT_LITERAL: 0b1010 (2:14)
    ├── VAR_DECL: let (3:10)
        ├── IDENTIFIER: octal (3:5)
        └── INT_LITERAL: 0755 (3:13)
    ├── VAR_DECL: let (4:8)
        ├── IDENTIFIER: hex (4:5)
        └── INT_LITERAL: 0xFF (4:11)
    ├── VAR_DECL: let (7:14)
        ├── IDENTIFIER: float_num (7:5)
        └── FLOAT_LITERAL: 3.14159 (7:17)
    ├── VAR_DECL: let (8:15)
        ├── IDENTIFIER: scientific (8:5)
        └── FLOAT_LITERAL: 1.23e-4 (8:18)
    ├── VAR_DECL: let (9:12)
        ├── IDENTIFIER: big_num (9:5)
        └── FLOAT_LITERAL: 6.022E23 (9:15)
    ├── FUNC_DECL (13:5)
        ├── ANNOTATIONS (12:2)
            └── ANNOTATION: deprecated (12:2)
        ├── IDENTIFIER: old_function (13:6)
        ├── PARAM_LIST (13:20)
        └── BLOCK (13:22)
            └── RETURN_STMT (14:11)
                └── INT_LITERAL: 0 (14:12)
    ├── FUNC_DECL (18:5)
        ├── IDENTIFIER: test_function (18:6)
        ├── PARAM_LIST (18:24)
            ├── PARAM (18:24)
                ├── IDENTIFIER: name (18:20)
                └── TYPE_IDENTIFIER: string (18:26)
            └── PARAM (18:37)
                ├── IDENTIFIER: age (18:34)
                └── TYPE_IDENTIFIER: i32 (18:39)
        └── BLOCK (18:45)
            ├── CALL_EXPR (20:10)
                ├── IDENTIFIER: pri32 (19:5)
                └── PARAM_LIST (19:19)
                    ├── STRING_LITERAL: Name:  (19:11)
                    └── IDENTIFIER: name (19:21)
            └── CALL_EXPR (21:2)
                ├── IDENTIFIER: pri32 (20:5)
                └── PARAM_LIST (20:18)
                    ├── STRING_LITERAL: Age:  (20:11)
                    └── IDENTIFIER: age (20:20)
    ├── CALL_EXPR (27:4)
        ├── IDENTIFIER: test_function (24:1)
        └── PARAM_LIST (24:19)
            ├── NAMED_ARG (24:15)
                ├── IDENTIFIER: name (24:15)
                └── STRING_LITERAL: Alice (24:21)
            └── NAMED_ARG (24:30)
                ├── IDENTIFIER: age (24:30)
                └── INT_LITERAL: 25 (24:35)
    ├── VAR_DECL: let (27:12)
        ├── IDENTIFIER: message (27:5)
        └── STRING_LITERAL: Hello, World! (27:15)
    ├── VAR_DECL: let (30:14)
        ├── IDENTIFIER: is_active (30:5)
        └── BOOL_LITERAL: true (30:17)
    ├── VAR_DECL: let (31:12)
        ├── IDENTIFIER: is_done (31:5)
        └── BOOL_LITERAL: false (31:15)
    ├── VAR_DECL: let (34:12)
        ├── IDENTIFIER: numbers (34:5)
        └── ARRAY_LITERAL (34:16)
            ├── INT_LITERAL: 1 (34:16)
            ├── INT_LITERAL: 2 (34:19)
            ├── INT_LITERAL: 3 (34:22)
            ├── INT_LITERAL: 4 (34:25)
            └── INT_LITERAL: 5 (34:28)
    ├── VAR_DECL: let (35:9)
        ├── IDENTIFIER: user (35:5)
        └── MAP_LITERAL (35:13)
            ├── MAP_ENTRY (36:11)
                ├── IDENTIFIER: name (36:5)
                └── STRING_LITERAL: Bob (36:13)
            ├── MAP_ENTRY (37:10)
                ├── IDENTIFIER: age (37:5)
        └── BINARY_EXPR: && (49:22)
            ├── BINARY_EXPR: <= (49:17)
                ├── IDENTIFIER: a (49:15)
                └── IDENTIFIER: b (49:20)
            └── BINARY_EXPR: >= (49:27)
                ├── IDENTIFIER: b (49:25)
                └── INT_LITERAL: 15 (49:30)
Testing file: ../demo/loop.vt
    => ✓
AST Tree:
└── PROGRAM (1:4)
    ├── VAR_DECL: let (1:6)
        ├── IDENTIFIER: a (1:5)
        ├── TYPE_IDENTIFIER: i32 (1:7)
        └── INT_LITERAL: 4 (1:13)
    ├── VAR_DECL: let (2:6)
        ├── IDENTIFIER: b (2:5)
        ├── TYPE_IDENTIFIER: i32 (2:7)
        └── INT_LITERAL: 3 (2:13)
    ├── VAR_DECL: let (3:6)
        ├── IDENTIFIER: c (3:5)
        ├── TYPE_IDENTIFIER: i32 (3:7)
        └── INT_LITERAL: 56 (3:13)
    ├── FOR_STMT (5:4)
        ├── FOR_INIT (5:9)
            └── VAR_DECL: let (5:11)
                ├── IDENTIFIER: i (5:10)
                ├── TYPE_IDENTIFIER: i32 (5:12)
                └── INT_LITERAL: 0 (5:18)
        ├── FOR_CONDITION (5:22)
            └── BINARY_EXPR: < (5:23)
                ├── IDENTIFIER: i (5:21)
                └── INT_LITERAL: 10 (5:25)
        ├── FOR_UPDATE (5:30)
            └── POSTFIX_EXPR: ++ (5:30)
                └── IDENTIFIER: i (5:29)
        └── BLOCK (5:35)
            └── CALL_EXPR (7:2)
                ├── IDENTIFIER: pri32 (6:5)
                └── PARAM_LIST (6:12)
                    └── IDENTIFIER: i (6:11)
    ├── WHILE_STMT (9:6)
        ├── BOOL_LITERAL: true (9:8)
        └── BLOCK (9:15)
            └── CALL_EXPR (11:2)
                ├── IDENTIFIER: pri32 (10:5)
                └── PARAM_LIST (10:26)
                    └── STRING_LITERAL: infinite loop (10:11)
    ├── WHILE_STMT (13:6)
        ├── BINARY_EXPR: and (13:14)
            ├── BINARY_EXPR: > (13:10)
                ├── IDENTIFIER: a (13:8)
                └── INT_LITERAL: 0 (13:12)
            └── BINARY_EXPR: or (13:25)
                ├── BINARY_EXPR: > (13:21)
                    ├── IDENTIFIER: b (13:19)
                    └── INT_LITERAL: 0 (13:23)
                └── BINARY_EXPR: > (13:30)
                    ├── IDENTIFIER: c (13:28)
                    └── INT_LITERAL: 0 (13:32)
        └── BLOCK (13:37)
            └── CALL_EXPR (15:2)
                ├── IDENTIFIER: pri32 (14:5)
                └── PARAM_LIST (14:26)
                    └── STRING_LITERAL: infinite loop (14:11)
    └── FOR_STMT (17:4)
        ├── FOR_INIT (17:9)
            └── VAR_DECL: let (17:11)
                ├── IDENTIFIER: i (17:10)
                ├── TYPE_IDENTIFIER: i32 (17:12)
                └── INT_LITERAL: 0 (17:18)
        ├── FOR_CONDITION (17:22)
            └── BINARY_EXPR: < (17:23)
                ├── IDENTIFIER: i (17:21)
                └── INT_LITERAL: 10 (17:25)
        ├── FOR_UPDATE (17:30)
            └── POSTFIX_EXPR: ++ (17:30)
                └── IDENTIFIER: i (17:29)
        └── BLOCK (17:35)
            └── IF_STMT (18:7)
                ├── BINARY_EXPR: == (18:11)
                    ├── IDENTIFIER: i (18:9)
                    └── INT_LITERAL: 5 (18:14)
                ├── BLOCK (18:18)
                    └── BREAK_STMT (19:14)
                └── ELSE_IF (20:16)
                    ├── BINARY_EXPR: == (20:18)
                        ├── IDENTIFIER: i (20:16)
                        └── INT_LITERAL: 3 (20:21)
                    └── BLOCK (20:25)
                        └── CONTINUE_STMT (21:17)
Testing file: ../demo/main.vt
    => ✓
AST Tree:
└── PROGRAM (1:7)
    ├── IMPORT_STMT (1:7)
        ├── IMPORT_PATH (1:10)
            ├── IDENTIFIER: io (1:8)
            ├── IDENTIFIER: bf (1:11)
            └── IDENTIFIER: ff (1:14)
        └── IMPORT_ALIAS: oo (1:20)
    ├── FUNC_DECL: native (3:7)
        ├── IDENTIFIER: print (3:13)
        ├── PARAM_LIST (3:22)
            └── PARAM (3:22)
                ├── IDENTIFIER: msg (3:19)
                └── TYPE_IDENTIFIER: i32 (3:24)
        └── TYPE_IDENTIFIER: i32 (3:30)
    ├── VAR_DECL: let (5:6)
        ├── IDENTIFIER: a (5:5)
        ├── TYPE_IDENTIFIER: i32 (5:8)
        └── INT_LITERAL: 1 (5:14)
    ├── VAR_DECL: const (6:8)
        ├── IDENTIFIER: b (6:7)
        ├── TYPE_IDENTIFIER: i32 (6:10)
        └── INT_LITERAL: 2 (6:16)
    ├── VAR_DECL: let (7:6)
        ├── IDENTIFIER: m (7:5)
        ├── TYPE_IDENTIFIER: any (7:7)
        └── MAP_LITERAL (7:14)
            ├── MAP_ENTRY (8:6)
                ├── IDENTIFIER: a (8:5)
                └── INT_LITERAL: 6 (8:7)
            ├── MAP_ENTRY (9:6)
                ├── IDENTIFIER: b (9:5)
                └── INT_LITERAL: 9 (9:7)
            └── MAP_ENTRY (10:6)
                ├── IDENTIFIER: c (10:5)
                └── MAP_LITERAL (10:9)
                    └── MAP_ENTRY (11:10)
                        ├── IDENTIFIER: d (11:9)
                        └── INT_LITERAL: 9 (11:11)
    ├── VAR_DECL: let (14:6)
        ├── IDENTIFIER: a (14:5)
        ├── ARRAY_TYPE: i32 (14:7)
        └── ARRAY_LITERAL (14:16)
            ├── INT_LITERAL: 1 (14:16)
            ├── INT_LITERAL: 2 (14:18)
            ├── INT_LITERAL: 2 (14:20)
            └── INT_LITERAL: 3 (14:22)
    ├── FUNC_DECL (16:5)
        ├── IDENTIFIER: test (16:6)
        ├── PARAM_LIST (16:14)
            └── PARAM (16:14)
                ├── IDENTIFIER: msg (16:11)
                └── TYPE_IDENTIFIER: i32 (16:16)
        ├── TYPE_IDENTIFIER: i32 (16:22)
        └── BLOCK (16:27)
            ├── CALL_EXPR (18:11)
                ├── IDENTIFIER: print (17:5)
                └── PARAM_LIST (17:19)
                    └── STRING_LITERAL: a is 1 (17:11)
            └── RETURN_STMT (18:11)
                └── INT_LITERAL: 0 (18:12)
    ├── FUNC_DECL (22:5)
        ├── ANNOTATIONS (21:2)
            └── ANNOTATION: test (21:2)
                └── NAMED_ARG (21:7)
                    ├── IDENTIFIER: debug (21:7)
                    └── INT_LITERAL: 6 (21:13)
        ├── IDENTIFIER: add (22:6)
        ├── PARAM_LIST (22:11)
            ├── PARAM (22:11)
                ├── IDENTIFIER: a (22:10)
                └── TYPE_IDENTIFIER: i32 (22:13)
            └── PARAM (22:19)
                ├── IDENTIFIER: b (22:18)
                └── TYPE_IDENTIFIER: i32 (22:21)
        ├── TYPE_IDENTIFIER: i32 (22:26)
        └── BLOCK (22:31)
            └── RETURN_STMT (23:11)
                └── BINARY_EXPR: + (23:14)
                    ├── IDENTIFIER: a (23:12)
                    └── IDENTIFIER: b (23:16)
    ├── FUNC_DECL (27:5)
        ├── IDENTIFIER: bubbleSort (27:6)
        ├── PARAM_LIST (27:20)
            ├── PARAM (27:20)
                ├── IDENTIFIER: arr (27:17)
                └── TYPE_IDENTIFIER: array (27:22)
            └── PARAM (27:30)
                ├── IDENTIFIER: n (27:29)
                └── TYPE_IDENTIFIER: i32 (27:32)
        ├── TYPE_IDENTIFIER: void (27:38)
        └── BLOCK (27:44)
            └── FOR_STMT (28:8)
                ├── FOR_INIT (28:12)
                    └── VAR_DECL: let (28:14)
                        ├── IDENTIFIER: i (28:13)
                        ├── TYPE_IDENTIFIER: i32 (28:15)
                        └── INT_LITERAL: 0 (28:21)
                ├── FOR_CONDITION (28:25)
                    └── BINARY_EXPR: < (28:26)
                        ├── IDENTIFIER: i (28:24)
                        └── BINARY_EXPR: - (28:29)
                            ├── IDENTIFIER: n (28:28)
                            └── INT_LITERAL: 1 (28:30)
                ├── FOR_UPDATE (28:34)
                    └── POSTFIX_EXPR: ++ (28:34)
                        └── IDENTIFIER: i (28:33)
                └── BLOCK (28:39)
                    └── FOR_STMT (29:12)
                        ├── FOR_INIT (29:17)
                            └── VAR_DECL: let (29:19)
                                ├── IDENTIFIER: j (29:18)
                                ├── TYPE_IDENTIFIER: i32 (29:20)
                                └── INT_LITERAL: 0 (29:26)
                        ├── FOR_CONDITION (29:30)
                            └── BINARY_EXPR: < (29:31)
                                ├── IDENTIFIER: j (29:29)
                                └── BINARY_EXPR: - (29:36)
                                    ├── BINARY_EXPR: - (29:34)
                                        ├── IDENTIFIER: n (29:33)
                                        └── IDENTIFIER: i (29:35)
                                    └── INT_LITERAL: 1 (29:37)
                        ├── FOR_UPDATE (29:41)
                            └── POSTFIX_EXPR: ++ (29:41)
                                └── IDENTIFIER: j (29:40)
                        └── BLOCK (29:46)
                            └── IF_STMT (30:15)
                                ├── BINARY_EXPR: > (30:24)
                                    ├── INDEX_EXPR (30:20)
                                        ├── IDENTIFIER: arr (30:17)
                                        └── IDENTIFIER: j (30:21)
                                    └── INDEX_EXPR (30:29)
                                        ├── IDENTIFIER: arr (30:26)
                                        └── BINARY_EXPR: + (30:31)
                                            ├── IDENTIFIER: j (30:30)
                                            └── INT_LITERAL: 1 (30:32)
                                └── BLOCK (30:37)
                                    ├── VAR_DECL: let (31:25)
                                        ├── IDENTIFIER: temp (31:21)
                                        └── INDEX_EXPR (31:31)
                                            ├── IDENTIFIER: arr (31:28)
                                            └── IDENTIFIER: j (31:32)
                                    ├── BINARY_EXPR: = (33:20)
                                        ├── INDEX_EXPR (32:20)
                                            ├── IDENTIFIER: arr (32:17)
                                            └── IDENTIFIER: j (32:21)
                                        └── INDEX_EXPR (32:29)
                                            ├── IDENTIFIER: arr (32:26)
                                            └── BINARY_EXPR: + (32:31)
                                                ├── IDENTIFIER: j (32:30)
                                                └── INT_LITERAL: 1 (32:32)
                                    └── BINARY_EXPR: = (34:14)
                                        ├── INDEX_EXPR (33:20)
                                            ├── IDENTIFIER: arr (33:17)
                                            └── BINARY_EXPR: + (33:22)
                                                ├── IDENTIFIER: j (33:21)
                                                └── INT_LITERAL: 1 (33:23)
                                        └── IDENTIFIER: temp (33:28)
    ├── VAR_DECL: let (39:8)
        ├── IDENTIFIER: arr (39:5)
        ├── ARRAY_TYPE: i32 (39:10)
        └── ARRAY_LITERAL (39:19)
            ├── INT_LITERAL: 64 (39:19)
            ├── INT_LITERAL: 34 (39:23)
            ├── INT_LITERAL: 25 (39:27)
            ├── INT_LITERAL: 12 (39:31)
            ├── INT_LITERAL: 22 (39:35)
            ├── INT_LITERAL: 11 (39:39)
            └── INT_LITERAL: 90 (39:43)
    ├── VAR_DECL_LIST: let (40:15)
        ├── VAR_DECL: let (40:6)
            ├── IDENTIFIER: b (40:5)
            ├── TYPE_IDENTIFIER: i32 (40:7)
            └── INT_LITERAL: 4 (40:13)
        └── VAR_DECL: let (40:17)
            ├── IDENTIFIER: c (40:16)
            ├── TYPE_IDENTIFIER: i32 (40:18)
            └── INT_LITERAL: 5 (40:24)
    └── FUNC_DECL (44:5)
        ├── ANNOTATIONS (42:2)
            ├── ANNOTATION: test (42:2)
                └── NAMED_ARG (42:7)
                    ├── IDENTIFIER: debug (42:7)
                    └── INT_LITERAL: 6 (42:13)
            └── ANNOTATION: debug (43:2)
                ├── NAMED_ARG (43:8)
                    ├── IDENTIFIER: a (43:8)
                    └── INT_LITERAL: 1 (43:10)
                └── POS_ARG (43:13)
                    └── INT_LITERAL: 4 (43:12)
        ├── IDENTIFIER: add (44:6)
        ├── PARAM_LIST (44:11)
            ├── PARAM (44:11)
                ├── IDENTIFIER: a (44:10)
                └── TYPE_IDENTIFIER: i32 (44:13)
            └── PARAM (44:19)
                ├── IDENTIFIER: b (44:18)
                └── ARRAY_TYPE: i32 (44:21)
        ├── ARRAY_TYPE: i32 (44:28)
        └── BLOCK (44:35)
            └── RETURN_STMT (45:11)
                └── BINARY_EXPR: + (45:14)
                    ├── IDENTIFIER: a (45:12)
                    └── IDENTIFIER: b (45:16)
Testing file: ../demo/map.vt
    => ✓
AST Tree:
└── PROGRAM (2:4)
    ├── VAR_DECL: let (2:8)
        ├── IDENTIFIER: map (2:5)
        └── MAP_LITERAL (2:12)
            ├── MAP_ENTRY (3:7)
                ├── IDENTIFIER: name (3:3)
                └── STRING_LITERAL: John (3:9)
            ├── MAP_ENTRY (4:6)
                ├── IDENTIFIER: age (4:3)
                └── INT_LITERAL: 30 (4:8)
            └── MAP_ENTRY (5:12)
                ├── IDENTIFIER: isStudent (5:3)
                └── BOOL_LITERAL: false (5:14)
    ├── VAR_DECL: let (8:9)
        ├── IDENTIFIER: map1 (8:5)
        └── MAP_LITERAL (8:13)
            ├── MAP_ENTRY (9:6)
                ├── IDENTIFIER: b (9:5)
                └── STRING_LITERAL: a (9:8)
            └── MAP_ENTRY (10:6)
                ├── IDENTIFIER: w (10:5)
                └── MAP_LITERAL (10:9)
                    ├── MAP_ENTRY (11:10)
                        ├── IDENTIFIER: w (11:9)
                        └── INT_LITERAL: 2 (11:11)
                    └── MAP_ENTRY (12:10)
                        ├── IDENTIFIER: p (12:9)
                        └── INT_LITERAL: 3 (12:11)
    ├── VAR_DECL: let (16:9)
        ├── IDENTIFIER: map2 (16:5)
        └── MAP_LITERAL (16:13)
            └── MAP_ENTRY (17:4)
                ├── IDENTIFIER: a (17:3)
                └── MAP_LITERAL (17:7)
                    └── MAP_ENTRY (17:9)
                        ├── IDENTIFIER: b (17:8)
                        └── MAP_LITERAL (17:11)
                            └── MAP_ENTRY (17:13)
                                ├── IDENTIFIER: c (17:12)
                                └── MAP_LITERAL (17:16)
                                    └── MAP_ENTRY (17:18)
                                        ├── IDENTIFIER: d (17:17)
                                        └── INT_LITERAL: 9 (17:20)
    └── VAR_DECL: let (20:9)
        ├── IDENTIFIER: map3 (20:5)
        └── MAP_LITERAL (20:13)
            ├── MAP_ENTRY (20:14)
                ├── IDENTIFIER: a (20:13)
                └── INT_LITERAL: 1 (20:15)
            └── MAP_ENTRY (20:18)
                ├── IDENTIFIER: w (20:17)
                └── INT_LITERAL: 3 (20:19)
Testing file: ../demo/test_example.vt
    => ✓
AST Tree:
└── PROGRAM (4:5)
    ├── FUNC_DECL (4:5)
        ├── IDENTIFIER: add (4:6)
        ├── PARAM_LIST (4:13)
            ├── PARAM (4:13)
                ├── IDENTIFIER: i32 (4:10)
                └── TYPE_IDENTIFIER: a (4:15)
            └── PARAM (4:21)
                ├── IDENTIFIER: i32 (4:18)
                └── TYPE_IDENTIFIER: b (4:23)
        ├── TYPE_IDENTIFIER: i32 (4:26)
        └── BLOCK (4:31)
            └── RETURN_STMT (5:11)
                └── BINARY_EXPR: + (5:14)
                    ├── IDENTIFIER: a (5:12)
                    └── IDENTIFIER: b (5:16)
    ├── FUNC_DECL (9:5)
        ├── IDENTIFIER: bubbleSort (9:6)
        ├── PARAM_LIST (9:20)
            ├── PARAM (9:20)
                ├── IDENTIFIER: arr (9:17)
                └── TYPE_IDENTIFIER: array (9:22)
            └── PARAM (9:30)
                ├── IDENTIFIER: n (9:29)
                └── TYPE_IDENTIFIER: i32 (9:32)
        ├── TYPE_IDENTIFIER: void (9:38)
        └── BLOCK (9:44)
            └── FOR_STMT (10:8)
                ├── FOR_INIT (10:12)
                    └── VAR_DECL: let (10:16)
                        ├── IDENTIFIER: i32 (10:13)
                        ├── TYPE_IDENTIFIER: i (10:17)
                        └── INT_LITERAL: 0 (10:21)
                ├── FOR_CONDITION (10:25)
                    └── BINARY_EXPR: < (10:26)
                        ├── IDENTIFIER: i (10:24)
                        └── BINARY_EXPR: - (10:29)
                            ├── IDENTIFIER: n (10:28)
                            └── INT_LITERAL: 1 (10:30)
                ├── FOR_UPDATE (10:34)
                    └── POSTFIX_EXPR: ++ (10:34)
                        └── IDENTIFIER: i (10:33)
                └── BLOCK (10:39)
                    └── FOR_STMT (11:12)
                        ├── FOR_INIT (11:17)
                            └── VAR_DECL: let (11:21)
                                ├── IDENTIFIER: j32 (11:18)
                                ├── TYPE_IDENTIFIER: j (11:22)
                                └── INT_LITERAL: 0 (11:26)
                        ├── FOR_CONDITION (11:30)
                            └── BINARY_EXPR: < (11:31)
                                ├── IDENTIFIER: j (11:29)
                                └── BINARY_EXPR: - (11:36)
                                    ├── BINARY_EXPR: - (11:34)
                                        ├── IDENTIFIER: n (11:33)
                                        └── IDENTIFIER: i (11:35)
                                    └── INT_LITERAL: 1 (11:37)
                        ├── FOR_UPDATE (11:41)
                            └── POSTFIX_EXPR: ++ (11:41)
                                └── IDENTIFIER: j (11:40)
                        └── BLOCK (11:46)
                            └── IF_STMT (12:15)
                                ├── BINARY_EXPR: > (12:24)
                                    ├── INDEX_EXPR (12:20)
                                        ├── IDENTIFIER: arr (12:17)
                                        └── IDENTIFIER: j (12:21)
                                    └── INDEX_EXPR (12:29)
                                        ├── IDENTIFIER: arr (12:26)
                                        └── BINARY_EXPR: + (12:31)
                                            ├── IDENTIFIER: j (12:30)
                                            └── INT_LITERAL: 1 (12:32)
                                └── BLOCK (12:37)
                                    ├── VAR_DECL: let (13:25)
                                        ├── IDENTIFIER: temp (13:21)
                                        └── INDEX_EXPR (13:31)
                                            ├── IDENTIFIER: arr (13:28)
                                            └── IDENTIFIER: j (13:32)
                                    ├── BINARY_EXPR: = (15:20)
                                        ├── INDEX_EXPR (14:20)
                                            ├── IDENTIFIER: arr (14:17)
                                            └── IDENTIFIER: j (14:21)
                                        └── INDEX_EXPR (14:29)
                                            ├── IDENTIFIER: arr (14:26)
                                            └── BINARY_EXPR: + (14:31)
                                                ├── IDENTIFIER: j (14:30)
                                                └── INT_LITERAL: 1 (14:32)
                                    └── BINARY_EXPR: = (16:14)
                                        ├── INDEX_EXPR (15:20)
                                            ├── IDENTIFIER: arr (15:17)
                                            └── BINARY_EXPR: + (15:22)
                                                ├── IDENTIFIER: j (15:21)
                                                └── INT_LITERAL: 1 (15:23)
                                        └── IDENTIFIER: temp (15:28)
    └── FUNC_DECL (21:5)
        ├── IDENTIFIER: main (21:6)
        ├── PARAM_LIST (21:12)
        ├── TYPE_IDENTIFIER: i32 (21:13)
        └── BLOCK (21:18)
            ├── VAR_DECL: let (22:10)
                ├── IDENTIFIER: x (22:9)
                ├── TYPE_IDENTIFIER: i32 (22:11)
                └── INT_LITERAL: 10 (22:17)
            ├── VAR_DECL: let (23:10)
                ├── IDENTIFIER: y (23:9)
                ├── TYPE_IDENTIFIER: i32 (23:11)
                └── INT_LITERAL: 20 (23:17)
            ├── VAR_DECL: let (24:15)
                ├── IDENTIFIER: result (24:9)
                └── CALL_EXPR (24:21)
                    ├── IDENTIFIER: add (24:18)
                    └── PARAM_LIST (24:23)
                        ├── IDENTIFIER: x (24:22)
                        └── IDENTIFIER: y (24:25)
            ├── VAR_DECL: let (27:10)
                ├── IDENTIFIER: z (27:9)
                ├── TYPE_IDENTIFIER: i32 (27:11)
                └── BINARY_EXPR: * (27:25)
                    ├── BINARY_EXPR: + (27:20)
                        ├── IDENTIFIER: x (27:18)
                        └── IDENTIFIER: y (27:22)
                    └── INT_LITERAL: 2 (27:27)
            ├── IF_STMT (30:7)
                ├── BINARY_EXPR: > (30:11)
                    ├── IDENTIFIER: z (30:9)
                    └── INT_LITERAL: 50 (30:13)
                ├── BLOCK (30:18)
                    └── BINARY_EXPR: = (32:6)
                        ├── IDENTIFIER: z (31:9)
                        └── BINARY_EXPR: - (31:15)
                            ├── IDENTIFIER: z (31:13)
                            └── INT_LITERAL: 10 (31:17)
                └── ELSE_BLOCK (32:13)
                    └── BLOCK (32:13)
                        └── BINARY_EXPR: = (34:6)
                            ├── IDENTIFIER: z (33:9)
                            └── BINARY_EXPR: + (33:15)
                                ├── IDENTIFIER: z (33:13)
                                └── INT_LITERAL: 10 (33:17)
            ├── CALL_EXPR (37:12)
                ├── IDENTIFIER: println (36:5)
                └── PARAM_LIST (36:28)
                    └── STRING_LITERAL: Hello, World! (36:13)
            ├── CALL_EXPR (39:10)
                ├── IDENTIFIER: println (37:5)
                └── PARAM_LIST (37:22)
                    ├── STRING_LITERAL: Result: (37:13)
                    └── IDENTIFIER: result (37:24)
            ├── CALL_EXPR (41:11)
                ├── IDENTIFIER: print (39:5)
                └── PARAM_LIST (39:21)
                    └── CALL_EXPR (39:12)
                        ├── IDENTIFIER: bubbleSort (39:11)
                        └── PARAM_LIST (39:16)
                            ├── IDENTIFIER: arr (39:13)
                            └── IDENTIFIER: n (39:16)
            └── RETURN_STMT (41:11)
                └── IDENTIFIER: z (41:12)
Testing file: ../demo/try-catch.vt
    => ✓
AST Tree:
└── PROGRAM (3:4)
    ├── TRY_STMT (3:4)
        ├── BLOCK (3:6)
            ├── VAR_DECL: let (4:13)
                ├── IDENTIFIER: result (4:7)
                └── BINARY_EXPR: / (4:19)
                    ├── INT_LITERAL: 10 (4:16)
                    └── INT_LITERAL: 0 (4:21)
            ├── CALL_EXPR (6:8)
                ├── IDENTIFIER: println (5:3)
                └── PARAM_LIST (5:17)
                    └── IDENTIFIER: result (5:11)
            └── THROW_STMT (6:8)
                └── INT_LITERAL: 9 (6:9)
        └── CATCH_BLOCK (7:12)
            ├── IDENTIFIER: e (7:10)
            └── BLOCK (7:14)
                └── CALL_EXPR (9:2)
                    ├── IDENTIFIER: println (8:3)
                    └── PARAM_LIST (8:30)
                        └── BINARY_EXPR: + (8:31)
                            ├── STRING_LITERAL: 捕获到异常:  (8:11)
                            └── IDENTIFIER: e (8:33)
    └── TRY_STMT (11:4)
        ├── BLOCK (11:6)
        └── CATCH_BLOCK (11:16)
            ├── IDENTIFIER: e (11:14)
            └── BLOCK (11:18)