diff --git a/src/01_lexic/comment.zig b/src/01_lexic/comment.zig
index 9e1e008..bddfa27 100644
--- a/src/01_lexic/comment.zig
+++ b/src/01_lexic/comment.zig
@@ -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;
diff --git a/src/01_lexic/number.zig b/src/01_lexic/number.zig
index 3cb1a6d..8d315d9 100644
--- a/src/01_lexic/number.zig
+++ b/src/01_lexic/number.zig
@@ -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;
diff --git a/src/01_lexic/root.zig b/src/01_lexic/root.zig
index 3c83b18..3393485 100644
--- a/src/01_lexic/root.zig
+++ b/src/01_lexic/root.zig
@@ -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;
diff --git a/src/01_lexic/string.zig b/src/01_lexic/string.zig
index cb6ab0d..08b60e8 100644
--- a/src/01_lexic/string.zig
+++ b/src/01_lexic/string.zig
@@ -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;
diff --git a/src/02_syntax/expression.zig b/src/02_syntax/expression.zig
index 3b80c51..f5b8f92 100644
--- a/src/02_syntax/expression.zig
+++ b/src/02_syntax/expression.zig
@@ -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();
 
diff --git a/src/02_syntax/root.zig b/src/02_syntax/root.zig
index 8fd1e73..15597f9 100644
--- a/src/02_syntax/root.zig
+++ b/src/02_syntax/root.zig
@@ -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);
 }
diff --git a/src/02_syntax/statement.zig b/src/02_syntax/statement.zig
index 6441949..4c586c9 100644
--- a/src/02_syntax/statement.zig
+++ b/src/02_syntax/statement.zig
@@ -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);
 }
diff --git a/src/02_syntax/variable.zig b/src/02_syntax/variable.zig
index 0ec91aa..22d66a4 100644
--- a/src/02_syntax/variable.zig
+++ b/src/02_syntax/variable.zig
@@ -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);
 }