fernando/thp-zig
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: fix tests to new compiler context

Browse Source
This commit is contained in:
Fernando Araoz 2025-01-31 06:35:42 -05:00
parent d0feb04b55
commit 56b840e09e
8 changed files with 26 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/01_lexic/comment.zig
View File

@ -2,7 +2,6 @@ const std = @import("std");
const assert = std.debug.assert;
const token = @import("./token.zig");
const utils = @import("./utils.zig");
const errors = @import("errors");
const context = @import("context");
const Token = token.Token;

1
src/01_lexic/number.zig
View File

@ -2,7 +2,6 @@ const std = @import("std");
const assert = std.debug.assert;
const token = @import("./token.zig");
const utils = @import("./utils.zig");
const errors = @import("errors");
const context = @import("context");
const Token = token.Token;

1
src/01_lexic/root.zig
View File

@ -10,7 +10,6 @@ const string = @import("string.zig");
const grouping = @import("grouping.zig");
const punctuation = @import("punctiation.zig");
const errors = @import("errors");
const context = @import("context");
pub const TokenType = token.TokenType;

1
src/01_lexic/string.zig
View File

@ -2,7 +2,6 @@ const std = @import("std");
const assert = std.debug.assert;
const token = @import("./token.zig");
const utils = @import("./utils.zig");
const errors = @import("errors");
const context = @import("context");
const Token = token.Token;

5
src/02_syntax/expression.zig
View File

@ -1,6 +1,5 @@
const std = @import("std");
const lexic = @import("lexic");
const errors = @import("errors");
const context = @import("context");
const Token = lexic.Token;
@ -32,8 +31,6 @@ test "should parse expression" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "322";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
@ -50,8 +47,6 @@ test "should fail on non expression" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "identifier";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();

18
src/02_syntax/root.zig
View File

@ -1,6 +1,5 @@
const std = @import("std");
const lexic = @import("lexic");
const errors = @import("errors");
const context = @import("context");
const expression = @import("./expression.zig");
@ -68,9 +67,9 @@ pub const Module = struct {
};
}
pub fn deinit(self: @This()) void {
pub fn deinit(self: @This(), ctx: *context.CompilerContext) void {
for (self.statements.items) |stmt| {
stmt.deinit();
stmt.deinit(ctx);
}
self.statements.deinit();
}
@ -84,29 +83,24 @@ test "should parse a single statement" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_variable = 322";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var module: Module = undefined;
_ = try module.init(&tokens, 0, std.testing.allocator, &error_list);
defer module.deinit();
_ = try module.init(&tokens, 0, &ctx);
defer module.deinit(&ctx);
}
test "should clean memory if a statement parsing fails after one item has been inserted" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_variable = 322 unrelated()";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var module: Module = undefined;
_ = module.init(&tokens, 0, std.testing.allocator, &error_list) catch {
_ = module.init(&tokens, 0, &ctx) catch {
return;
};
defer module.deinit();
defer module.deinit(&ctx);
}

12
src/02_syntax/statement.zig
View File

@ -4,7 +4,6 @@ const expression = @import("expression.zig");
const types = @import("./types.zig");
const utils = @import("./utils.zig");
const variable = @import("./variable.zig");
const errors = @import("errors");
const context = @import("context");
const TokenStream = types.TokenStream;
@ -59,14 +58,12 @@ test "should parse a variable declaration statement" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_variable = 322";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var statement: Statement = undefined;
_ = try statement.init(&tokens, 0, undefined, std.testing.allocator);
defer statement.deinit();
_ = try statement.init(&tokens, 0, &ctx);
defer statement.deinit(&ctx);
switch (statement.value) {
.variableBinding => |v| {
@ -80,17 +77,16 @@ test "should fail on other constructs" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "a_function_call(322)";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var statement: Statement = undefined;
const result = try statement.init(&tokens, 0, undefined, std.testing.allocator);
const result = try statement.init(&tokens, 0, &ctx);
if (result == null) {
// good path
return;
}
defer statement.deinit(&ctx);
try std.testing.expect(false);
}

41
src/02_syntax/variable.zig
View File

@ -3,7 +3,6 @@ const lexic = @import("lexic");
const expression = @import("expression.zig");
const types = @import("./types.zig");
const utils = @import("./utils.zig");
const errors = @import("errors");
const context = @import("context");
const TokenStream = types.TokenStream;
@ -91,14 +90,12 @@ test "should parse a minimal var" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_variable = 322";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var binding: VariableBinding = undefined;
_ = try binding.init(&tokens, 0, undefined, std.testing.allocator);
defer binding.deinit();
_ = try binding.init(&tokens, 0, &ctx);
defer binding.deinit(&ctx);
try std.testing.expectEqual(true, binding.is_mutable);
try std.testing.expect(binding.datatype == null);
@ -115,13 +112,11 @@ test "should return null if stream doesnt start with var" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "different_token_stream()";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var binding: VariableBinding = undefined;
if (try binding.init(&tokens, 0, undefined, std.testing.allocator)) |_| {
if (try binding.init(&tokens, 0, &ctx)) |_| {
try std.testing.expect(false);
}
}
@ -130,15 +125,14 @@ test "should fail if the identifier is missing" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var ";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var error_data: errors.ErrorData = undefined;
var binding: VariableBinding = undefined;
_ = binding.init(&tokens, 0, &error_data, std.testing.allocator) catch |err| {
defer error_data.deinit();
_ = binding.init(&tokens, 0, &ctx) catch |err| {
try std.testing.expectEqual(1, ctx.errors.items.len);
const error_data = ctx.errors.items[0];
try std.testing.expectEqual(ParseError.Error, err);
try std.testing.expectEqualStrings("Incomplete variable declaration", error_data.reason);
try std.testing.expectEqual(0, error_data.start_position);
@ -149,6 +143,7 @@ test "should fail if the identifier is missing" {
try std.testing.expectEqual(3, l.end);
return;
};
defer binding.deinit(&ctx);
try std.testing.expect(false);
}
@ -157,16 +152,15 @@ test "should fail if there is not an identifier after var" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var 322";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var binding: VariableBinding = undefined;
_ = binding.init(&tokens, 0, undefined, std.testing.allocator) catch |err| {
_ = binding.init(&tokens, 0, &ctx) catch |err| {
try std.testing.expectEqual(ParseError.Error, err);
return;
};
defer binding.deinit(&ctx);
try std.testing.expect(false);
}
@ -175,16 +169,15 @@ test "should fail if the equal sign is missing" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_id ";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var binding: VariableBinding = undefined;
_ = binding.init(&tokens, 0, undefined, std.testing.allocator) catch |err| {
_ = binding.init(&tokens, 0, &ctx) catch |err| {
try std.testing.expectEqual(ParseError.Error, err);
return;
};
defer binding.deinit(&ctx);
try std.testing.expect(false);
}
@ -193,16 +186,15 @@ test "should fail if the equal sign is not found" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_id is string";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var binding: VariableBinding = undefined;
_ = binding.init(&tokens, 0, undefined, std.testing.allocator) catch |err| {
_ = binding.init(&tokens, 0, &ctx) catch |err| {
try std.testing.expectEqual(ParseError.Error, err);
return;
};
defer binding.deinit(&ctx);
try std.testing.expect(false);
}
@ -211,16 +203,15 @@ test "should fail if the expression parsing fails" {
var ctx = context.CompilerContext.init(std.testing.allocator);
defer ctx.deinit();
const input = "var my_id = ehhh";
var error_list = std.ArrayList(errors.ErrorData).init(std.testing.allocator);
defer error_list.deinit();
const tokens = try lexic.tokenize(input, &ctx);
defer tokens.deinit();
var binding: VariableBinding = undefined;
_ = binding.init(&tokens, 0, undefined, std.testing.allocator) catch |err| {
_ = binding.init(&tokens, 0, &ctx) catch |err| {
try std.testing.expectEqual(ParseError.Error, err);
return;
};
defer binding.deinit(&ctx);
try std.testing.expect(false);
}