lib/chant/src/parse/state/memory.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const ast = @import("../../ast/root.zig");
 2 const origin = @import("origin.zig");
 3 const types = @import("types.zig");
 4 const Error = @import("../root.zig").Error;
 5 
 6 const Parser = types.Parser;
 7 
 8 pub fn create(parser: *Parser, comptime T: type, value: T) Error!*T {
 9     if (T == ast.Expr) return parser.nodes.createExpr(value);
10     if (T == ast.Stmt) return parser.nodes.createStmt(value);
11     if (T == ast.Type) {
12         @compileError("use createType with an explicit token charge");
13     }
14     @compileError("parser node storage does not cover " ++ @typeName(T));
15 }
16 
17 pub fn createExprAt(
18     parser: *Parser,
19     value: ast.Expr,
20     token_index: usize,
21 ) Error!*ast.Expr {
22     return parser.nodes.createExprAt(value, token_index);
23 }
24 
25 pub fn createType(
26     parser: *Parser,
27     value: ast.Type,
28     placement: origin.TypePlacement,
29 ) Error!*ast.Type {
30     return parser.nodes.createType(value, placement);
31 }
32 
33 pub fn directType(
34     token_index: usize,
35     secondary_index: ?usize,
36 ) origin.TypePlacement {
37     return .{
38         .charged = token_index,
39         .origin = .{
40             .primary = token_index,
41             .secondary = secondary_index orelse origin.no_token,
42         },
43     };
44 }
45 
46 pub fn derivedType(
47     type_origin: origin.TypeOrigin,
48     secondary: bool,
49 ) origin.TypePlacement {
50     return .{
51         .charged = if (secondary) type_origin.secondary else type_origin.primary,
52         .origin = type_origin,
53     };
54 }