879 lines
73 KiB
Plaintext
879 lines
73 KiB
Plaintext
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)
|