Expression refactor
This commit is contained in:
parent
1269aeeac1
commit
54748b4c07
|
|
@ -211,34 +211,7 @@ fn print(writer: anytype, arg: anytype) !void {
|
|||
try std.fmt.format(writer, "{}", .{arg});
|
||||
}
|
||||
|
||||
const DerefError = error{NullOptional};
|
||||
fn Deref(comptime T: type, comptime names: []const DerefDecl) type {
|
||||
if (names.len == 0) return T;
|
||||
|
||||
// Compiler segfaults when I use std.meta to get this info so we search it manually
|
||||
const F = switch (names[0]) {
|
||||
.field => |name| blk: {
|
||||
const field = for (@typeInfo(T).Struct.fields) |f| {
|
||||
if (std.mem.eql(u8, f.name, name)) break f;
|
||||
} else @compileError("Unknown field " ++ name ++ " in type " ++ @typeName(T));
|
||||
break :blk field.field_type;
|
||||
},
|
||||
.optional_unwrap => std.meta.Child(T),
|
||||
};
|
||||
|
||||
return Deref(F, names[1..]);
|
||||
}
|
||||
|
||||
fn deref(arg: anytype, comptime names: []const DerefDecl) DerefError!Deref(@TypeOf(arg), names) {
|
||||
if (names.len == 0) return arg;
|
||||
|
||||
switch (names[0]) {
|
||||
.field => |name| return deref(@field(arg, name), names[1..]),
|
||||
.optional_unwrap => return arg orelse error.NullOptional,
|
||||
}
|
||||
}
|
||||
|
||||
const ExpressionError = error{IndexOutOfBounds} || DerefError;
|
||||
const ExpressionError = error{ IndexOutOfBounds, NullOptional };
|
||||
|
||||
fn EvaluateExpression(
|
||||
comptime expression: Expression,
|
||||
|
|
@ -247,14 +220,21 @@ fn EvaluateExpression(
|
|||
comptime Context: type,
|
||||
) type {
|
||||
return switch (expression) {
|
||||
.arg_deref => |names| Deref(Args, names),
|
||||
.capture_deref => |names| Deref(Captures, names),
|
||||
.context_deref => |names| Deref(Context, names),
|
||||
.args => Args,
|
||||
.captures => Captures,
|
||||
.context => Context,
|
||||
.deref => |expr| {
|
||||
const T = EvaluateExpression(expr.container, Args, Captures, Context);
|
||||
for (@typeInfo(T).Struct.fields) |f| {
|
||||
if (std.mem.eql(u8, expr.field, f.name)) return f.field_type;
|
||||
}
|
||||
},
|
||||
.equals => bool,
|
||||
.builtin => |call| switch (call.*) {
|
||||
.isTag => bool,
|
||||
.slice => |sl| []const std.meta.Elem(EvaluateExpression(sl.iterable, Args, Captures, Context)),
|
||||
},
|
||||
.optional_unwrap => |expr| std.meta.Child(EvaluateExpression(expr, Args, Captures, Context)),
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -265,9 +245,15 @@ fn evaluateExpression(
|
|||
context: anytype,
|
||||
) ExpressionError!EvaluateExpression(expression, @TypeOf(args), @TypeOf(captures), @TypeOf(context)) {
|
||||
return switch (expression) {
|
||||
.arg_deref => |names| try deref(args, names),
|
||||
.capture_deref => |names| try deref(captures, names),
|
||||
.context_deref => |names| try deref(context, names),
|
||||
.args => args,
|
||||
.captures => captures,
|
||||
.context => context,
|
||||
.deref => |expr| {
|
||||
return @field(
|
||||
try evaluateExpression(expr.container, args, captures, context),
|
||||
expr.field,
|
||||
);
|
||||
},
|
||||
.equals => |eql| {
|
||||
const lhs = try evaluateExpression(eql.lhs, args, captures, context);
|
||||
const rhs = try evaluateExpression(eql.rhs, args, captures, context);
|
||||
|
|
@ -293,6 +279,7 @@ fn evaluateExpression(
|
|||
return iterable[start..end];
|
||||
},
|
||||
},
|
||||
.optional_unwrap => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -566,54 +553,66 @@ fn parseExpression(comptime tokens: ControlTokenIter) ParseResult(ControlTokenIt
|
|||
|
||||
var last_valid_iter: ?ControlTokenIter = null;
|
||||
var expr: ?Expression = null;
|
||||
while (iter.next()) |token| switch (token) {
|
||||
.whitespace => {},
|
||||
.period => {
|
||||
const names = parseDeref(iter);
|
||||
iter = names.new_iter;
|
||||
if (expr != null) break;
|
||||
expr = .{ .arg_deref = names.item };
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
.dollar => {
|
||||
const names = parseDeref(iter);
|
||||
iter = names.new_iter;
|
||||
if (expr != null) break;
|
||||
expr = .{ .capture_deref = names.item };
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
.percent => {
|
||||
const names = parseDeref(iter);
|
||||
iter = names.new_iter;
|
||||
if (expr != null) break;
|
||||
expr = .{ .context_deref = names.item };
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
.equals => {
|
||||
const next = iter.next() orelse break;
|
||||
if (next == .equals) {
|
||||
const lhs = expr orelse break;
|
||||
const rhs = parseExpression(iter);
|
||||
iter = rhs.new_iter;
|
||||
|
||||
expr = .{
|
||||
.equals = &.{
|
||||
.lhs = lhs,
|
||||
.rhs = rhs.item,
|
||||
},
|
||||
};
|
||||
while (iter.next()) |token| {
|
||||
switch (token) {
|
||||
.whitespace => {},
|
||||
.period => {
|
||||
iter = skipWhitespace(iter);
|
||||
if (expr == null) {
|
||||
expr = .{ .args = {} };
|
||||
if (iter.peek()) |n| if (n == .text) iter.putBack(.{ .period = {} });
|
||||
} else {
|
||||
const field = iter.next();
|
||||
expectToken(field, .text);
|
||||
expr = .{
|
||||
.deref = &.{
|
||||
.container = expr.?,
|
||||
.field = field.?.text,
|
||||
},
|
||||
};
|
||||
}
|
||||
last_valid_iter = iter;
|
||||
} else break;
|
||||
},
|
||||
.at => {
|
||||
if (expr != null) break;
|
||||
const builtin = parseBuiltin(iter);
|
||||
iter = builtin.new_iter;
|
||||
expr = .{ .builtin = &builtin.item };
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
else => break,
|
||||
};
|
||||
},
|
||||
.dollar => {
|
||||
if (expr != null) break;
|
||||
iter = skipWhitespace(iter);
|
||||
expr = .{ .captures = {} };
|
||||
if (iter.peek()) |n| if (n == .text) iter.putBack(.{ .period = {} });
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
.percent => {
|
||||
if (expr != null) break;
|
||||
iter = skipWhitespace(iter);
|
||||
expr = .{ .context = {} };
|
||||
if (iter.peek()) |n| if (n == .text) iter.putBack(.{ .period = {} });
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
.equals => {
|
||||
const next = iter.next() orelse break;
|
||||
if (next == .equals) {
|
||||
const lhs = expr orelse break;
|
||||
const rhs = parseExpression(iter);
|
||||
iter = rhs.new_iter;
|
||||
|
||||
expr = .{
|
||||
.equals = &.{
|
||||
.lhs = lhs,
|
||||
.rhs = rhs.item,
|
||||
},
|
||||
};
|
||||
last_valid_iter = iter;
|
||||
} else break;
|
||||
},
|
||||
.at => {
|
||||
if (expr != null) break;
|
||||
const builtin = parseBuiltin(iter);
|
||||
iter = builtin.new_iter;
|
||||
expr = .{ .builtin = &builtin.item };
|
||||
last_valid_iter = iter;
|
||||
},
|
||||
else => break,
|
||||
}
|
||||
}
|
||||
|
||||
return .{
|
||||
.new_iter = last_valid_iter orelse @compileError("Invalid Expression"),
|
||||
|
|
@ -972,40 +971,6 @@ fn parseSwitchHeader(comptime tokens: ControlTokenIter) ParseResult(ControlToken
|
|||
}
|
||||
}
|
||||
|
||||
fn parseDeref(comptime tokens: ControlTokenIter) ParseResult(ControlTokenIter, []const DerefDecl) {
|
||||
comptime {
|
||||
var iter = tokens;
|
||||
var fields: []const DerefDecl = &.{};
|
||||
var wants = .text;
|
||||
while (iter.peek()) |token| {
|
||||
switch (token) {
|
||||
.whitespace => {},
|
||||
.text => |text| {
|
||||
if (wants == .period) break;
|
||||
fields = fields ++ [1]DerefDecl{.{ .field = text }};
|
||||
wants = .period;
|
||||
},
|
||||
.period => {
|
||||
if (wants != .period) @compileError("Unexpected token \".\"");
|
||||
wants = .text;
|
||||
},
|
||||
.question_mark => {
|
||||
if (wants == .period) break;
|
||||
fields = fields ++ [1]DerefDecl{.{ .optional_unwrap = {} }};
|
||||
wants = .period;
|
||||
},
|
||||
else => if (wants == .period or fields.len == 0) break else @compileError("Unexpected token"),
|
||||
}
|
||||
_ = iter.next();
|
||||
}
|
||||
|
||||
return .{
|
||||
.new_iter = iter,
|
||||
.item = fields,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
fn parseCallTemplate(comptime tokens: ControlTokenIter) ParseResult(ControlTokenIter, CallTemplate) {
|
||||
comptime {
|
||||
var iter = tokens;
|
||||
|
|
@ -1076,9 +1041,9 @@ const TemplateItem = union(enum) {
|
|||
statement: Statement,
|
||||
};
|
||||
|
||||
const DerefDecl = union(enum) {
|
||||
const DerefExpr = struct {
|
||||
container: Expression,
|
||||
field: []const u8,
|
||||
optional_unwrap: void,
|
||||
};
|
||||
|
||||
const EqualsExpr = struct {
|
||||
|
|
@ -1087,11 +1052,13 @@ const EqualsExpr = struct {
|
|||
};
|
||||
|
||||
const Expression = union(enum) {
|
||||
arg_deref: []const DerefDecl,
|
||||
capture_deref: []const DerefDecl,
|
||||
context_deref: []const DerefDecl,
|
||||
args: void,
|
||||
captures: void,
|
||||
context: void,
|
||||
deref: *const DerefExpr,
|
||||
equals: *const EqualsExpr,
|
||||
builtin: *const BuiltinCall,
|
||||
optional_unwrap: *const Expression,
|
||||
};
|
||||
|
||||
const For = struct {
|
||||
|
|
@ -1235,14 +1202,17 @@ const ControlToken = union(enum) {
|
|||
const ControlTokenIter = struct {
|
||||
start: usize = 0,
|
||||
text: []const u8,
|
||||
peeked_token: ?ControlToken = null,
|
||||
peeked_tokens: [2]?ControlToken = [2]?ControlToken{ null, null },
|
||||
peeked_token_count: usize = 0,
|
||||
|
||||
row: usize = 0,
|
||||
|
||||
fn next(self: *ControlTokenIter) ?ControlToken {
|
||||
if (self.peeked_token) |token| {
|
||||
self.peeked_token = null;
|
||||
return token;
|
||||
if (self.peeked_token_count != 0) {
|
||||
const t = self.peeked_tokens[self.peeked_token_count - 1].?;
|
||||
self.peeked_tokens[self.peeked_token_count - 1] = null;
|
||||
self.peeked_token_count -= 1;
|
||||
return t;
|
||||
}
|
||||
|
||||
const remaining = self.text[self.start..];
|
||||
|
|
@ -1287,13 +1257,14 @@ const ControlTokenIter = struct {
|
|||
|
||||
fn peek(self: *ControlTokenIter) ?ControlToken {
|
||||
const token = self.next();
|
||||
self.peeked_token = token;
|
||||
if (token) |t| self.putBack(t);
|
||||
return token;
|
||||
}
|
||||
|
||||
fn putBack(self: *ControlTokenIter, token: ControlToken) void {
|
||||
std.debug.assert(self.peeked_token == null);
|
||||
self.peeked_token = token;
|
||||
std.debug.assert(self.peeked_token_count < self.peeked_tokens.len);
|
||||
self.peeked_tokens[self.peeked_token_count] = token;
|
||||
self.peeked_token_count += 1;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -1310,8 +1281,8 @@ test "template" {
|
|||
try testCase("abcd", .{}, "abcd");
|
||||
try testCase("{.val}", .{ .val = 3 }, "3");
|
||||
try testCase("{#if .val}1{/if}", .{ .val = true }, "1");
|
||||
try testCase("{#for .vals |$v|}{$v}{/for}", .{ .vals = [_]u8{ 1, 2, 3 } }, "123");
|
||||
try testCase("{#for .vals |$v|=} {$v} {=/for}", .{ .vals = [_]u8{ 1, 2, 3 } }, "123");
|
||||
try testCase("{#for .vals |$val|}{$val}{/for}", .{ .vals = [_]u8{ 1, 2, 3 } }, "123");
|
||||
try testCase("{#if .val}1{#else}0{/if}", .{ .val = true }, "1");
|
||||
try testCase("{#if .val}1{#else}0{/if}", .{ .val = false }, "0");
|
||||
try testCase("{#if .val}1{#elif .foo}2{/if}", .{ .val = false, .foo = true }, "2");
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@
|
|||
{#if .maybe_foo |$v|}{$v}{#else}null{/if}
|
||||
{#if .maybe_bar |$v|}{$v}{#else}null{/if}
|
||||
{#if .maybe_foo |$_|}abcd{#else}null{/if}
|
||||
{.maybe_foo.?}
|
||||
{{.maybe_foo.?}}
|
||||
This causes an error: {{.maybe_bar.?}}
|
||||
|
||||
<template>{#template test_tmpl .bar}</template>
|
||||
|
|
|
|||
Loading…
Reference in New Issue