add struct support

build.zig

@@ -67,14 +67,6 @@ pub fn build(b: *Build) !void {
         .root_module = exe_mod,
     });
     b.installArtifact(exe);
-    const run = b.addRunArtifact(exe);
-    run.addArgs(&.{
-        "lola",
-        "run",
-        "hello.lola",
-        "--mode",
-        "source",
-    });
 
     const benchmark_renderer_mod = b.createModule(.{
         .root_source_file = b.path("src/benchmark/render.zig"),
@@ -247,6 +239,9 @@ pub fn build(b: *Build) !void {
     }
 
     const run_cmd = b.addRunArtifact(exe);
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
     run_cmd.step.dependOn(b.getInstallStep());
 
     const run_step = b.step("run", "Run the app");

src/library/common/ir.zig

@@ -44,6 +44,9 @@ pub const InstructionName = enum(u8) {
     push_true = 41,
     push_false = 42,
     push_void = 43,
+    struct_pack = 44,
+    struct_store = 45,
+    struct_load = 46,
 };
 
 /// This union contains each possible instruction with its (optional) arguments already encoded.
@@ -106,4 +109,7 @@ pub const Instruction = union(InstructionName) {
     push_true: NoArg,
     push_false: NoArg,
     push_void: NoArg,
+    struct_pack: SingleArg(u16),
+    struct_store: NoArg,
+    struct_load: NoArg,
 };

src/library/compiler/analysis.zig

@@ -34,6 +34,8 @@ fn expressionTypeToString(src: ast.Expression.Type) []const u8 {
         .string_literal => "string literal",
         .unary_operator => "unary operator application",
         .binary_operator => "binary operator application",
+        .field_access => "field access",
+        .struct_literal => "struct literal",
     };
 }
 
@@ -74,6 +76,17 @@ fn validateExpression(state: *AnalysisState, diagnostics: *Diagnostics, scope: *
             }
         },
 
+        .field_access => |_| {
+            return TypeSet.any;
+        },
+
+        .struct_literal => |lit| {
+            for (lit) |entry| {
+                _ = try validateExpression(state, diagnostics, scope, entry.@"1".*);
+            }
+            return TypeSet.from(.@"struct");
+        },
+
         .variable_expr => |variable_name| {
 
             // Check reserved names
@@ -230,6 +243,12 @@ fn validateStore(state: *AnalysisState, diagnostics: *Diagnostics, scope: *Scope
             }
         },
 
+        .field_access => |field_access| {
+            const struct_val = try validateExpression(state, diagnostics, scope, field_access.@"struct".*);
+            try performTypeCheck(diagnostics, field_access.@"struct".location, .from(.@"struct"), struct_val);
+            try validateStore(state, diagnostics, scope, field_access.@"struct".*, struct_val);
+        },
+
         else => unreachable,
     }
 }
@@ -477,4 +496,3 @@ test "detect doubly-declared global variables" {
         "Global variable a is already declared!",
     });
 }
-

src/library/compiler/ast.zig

@@ -39,7 +39,7 @@ pub const Expression = struct {
     /// Cs `lvalue`.
     pub fn isAssignable(self: Self) bool {
         return switch (self.type) {
-            .array_indexer, .variable_expr => true,
+            .array_indexer, .variable_expr, .field_access => true,
             else => false,
         };
     }
@@ -51,6 +51,7 @@ pub const Expression = struct {
         },
         variable_expr: []const u8,
         array_literal: []Expression,
+        struct_literal: []struct { []const u8, *Expression },
         function_call: struct {
             // this must be a expression of type `variable_expr`
             function: *Expression,
@@ -72,6 +73,10 @@ pub const Expression = struct {
             lhs: *Expression,
             rhs: *Expression,
         },
+        field_access: struct {
+            @"struct": *Expression,
+            name: []const u8,
+        },
     };
 };
 

src/library/compiler/codegen.zig

@@ -49,6 +49,13 @@ fn emitStore(debug_symbols: *DebugSyms, scope: *Scope, writer: *CodeWriter, expr
             try emitStore(debug_symbols, scope, writer, indexer.value.*); // now store back the value on the stack
         },
 
+        .field_access => |field_access| {
+            try writer.emitInstruction(.{ .push_str = .{ .value = field_access.name } });
+            try emitExpression(debug_symbols, scope, writer, field_access.@"struct".*);
+            try writer.emitInstruction(.struct_store);
+            try emitStore(debug_symbols, scope, writer, field_access.@"struct".*);
+        },
+
         .variable_expr => |variable_name| {
             if (std.mem.eql(u8, variable_name, "true")) {
                 return error.InvalidStoreTarget;
@@ -119,6 +126,25 @@ fn emitExpression(debug_symbols: *DebugSyms, scope: *Scope, writer: *CodeWriter,
             });
         },
 
+        .field_access => |field_access| {
+            // field_access.
+            try writer.emitInstruction(.{ .push_str = .{ .value = field_access.name } });
+            try emitExpression(debug_symbols, scope, writer, field_access.@"struct".*);
+            try writer.emitInstruction(.struct_load);
+        },
+
+        .struct_literal => |s| {
+            var i: usize = s.len;
+            while (i > 0) {
+                i -= 1;
+                try writer.emitInstruction(.{ .push_str = .{ .value = s[i].@"0" } });
+                try emitExpression(debug_symbols, scope, writer, s[i].@"1".*);
+            }
+            try writer.emitInstruction(Instruction{
+                .struct_pack = .{ .value = @as(u16, @intCast(s.len)) },
+            });
+        },
+
         .function_call => |call| {
             var i: usize = call.arguments.len;
             while (i > 0) {

src/library/compiler/parser.zig

@@ -657,40 +657,53 @@ pub fn parse(
                         };
                     },
 
-                    // method call
+                    //field access or method call
                     .@"." => blk: {
-                        const method_name = try self.accept(is(.identifier));
-
-                        _ = try self.accept(is(.@"("));
-
-                        var args = std.ArrayList(ast.Expression).empty;
-                        defer args.deinit(self.allocator);
-
-                        var loc = value.location;
-
-                        if (self.accept(is(.@")"))) |_| {
-                            // this is the end of the argument list
-                        } else |_| {
-                            while (true) {
-                                const arg = try self.acceptExpression();
-                                try args.append(self.allocator, arg);
-                                const terminator = try self.accept(oneOf(.{ .@")", .@"," }));
-                                loc = terminator.location.merge(loc);
-                                if (terminator.type == .@")")
-                                    break;
+                        const field_name = try self.accept(is(.identifier));
+
+                        if (self.accept(is(.@"("))) |_| {
+                            // method call
+
+                            var args = std.ArrayList(ast.Expression).empty;
+                            defer args.deinit(self.allocator);
+
+                            var loc = value.location;
+
+                            if (self.accept(is(.@")"))) |_| {
+                                // this is the end of the argument list
+                            } else |_| {
+                                while (true) {
+                                    const arg = try self.acceptExpression();
+                                    try args.append(self.allocator, arg);
+                                    const terminator = try self.accept(oneOf(.{ .@")", .@"," }));
+                                    loc = terminator.location.merge(loc);
+                                    if (terminator.type == .@")")
+                                        break;
+                                }
                             }
-                        }
 
-                        break :blk ast.Expression{
-                            .location = loc,
-                            .type = .{
-                                .method_call = .{
-                                    .object = try self.moveToHeap(value),
-                                    .name = method_name.text,
-                                    .arguments = try args.toOwnedSlice(self.allocator),
+                            break :blk ast.Expression{
+                                .location = loc,
+                                .type = .{
+                                    .method_call = .{
+                                        .object = try self.moveToHeap(value),
+                                        .name = field_name.text,
+                                        .arguments = try args.toOwnedSlice(self.allocator),
+                                    },
                                 },
-                            },
-                        };
+                            };
+                        } else |_| {
+                            //field access
+                            break :blk ast.Expression{
+                                .location = value.location,
+                                .type = .{
+                                    .field_access = .{
+                                        .@"struct" = try self.moveToHeap(value),
+                                        .name = field_name.text,
+                                    },
+                                },
+                            };
+                        }
                     },
 
                     else => unreachable,
@@ -701,10 +714,63 @@ pub fn parse(
             return value;
         }
 
+        fn acceptStructExpression(self: *Self) ParseError!ast.Expression {
+            const state = self.saveState();
+            errdefer self.restoreState(state);
+
+            const token = try self.accept(is(.@"["));
+            var loc: Location = token.location;
+
+            var entries: std.ArrayList(struct { []const u8, *ast.Expression }) = .empty;
+            errdefer {
+                for (entries.items) |entry| {
+                    self.allocator.destroy(entry.@"1");
+                }
+                entries.deinit(self.allocator);
+            }
+            while (true) {
+                if (self.accept(is(.@"]"))) |_| {
+                    break;
+                } else |_| {
+                    _ = try self.accept(is(.@"."));
+                    const field = try self.accept(is(.identifier));
+                    _ = try self.accept(is(.@"="));
+                    const item = try self.acceptExpression();
+                    try entries.append(self.allocator, .{ field.text, try self.moveToHeap(item) });
+
+                    const delimit = try self.accept(oneOf(.{ .@",", .@"]" }));
+                    loc = loc.merge(delimit.location);
+                    if (delimit.type == .@"]")
+                        break;
+                }
+            }
+            if (entries.items.len == 0) {
+                //this is a list type by default
+                entries.deinit(self.allocator);
+                return ast.Expression{
+                    .location = loc,
+                    .type = .{ .array_literal = try self.allocator.alloc(ast.Expression, 0) },
+                };
+            }
+
+            return ast.Expression{
+                .location = loc,
+                .type = .{
+                    .struct_literal = try entries.toOwnedSlice(self.allocator),
+                },
+            };
+        }
+
         fn acceptValueExpression(self: *Self) ParseError!ast.Expression {
             const state = self.saveState();
             errdefer self.restoreState(state);
 
+            if (self.acceptStructExpression()) |t| {
+                return t;
+            } else |_| {
+                self.restoreState(state);
+            }
+
             const token = try self.accept(oneOf(.{
                 .@"(",
                 .@"[",
@@ -722,7 +788,6 @@ pub fn parse(
                 .@"[" => {
                     var array = std.ArrayList(ast.Expression).empty;
                     defer array.deinit(self.allocator);
-
                     while (true) {
                         if (self.accept(is(.@"]"))) |_| {
                             break;

src/library/compiler/typeset.zig

@@ -7,6 +7,7 @@ pub const Type = enum {
     boolean,
     array,
     object,
+    @"struct",
 
     pub fn format(value: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
         _ = fmt;
@@ -25,6 +26,7 @@ pub const TypeSet = struct {
         .boolean = false,
         .array = false,
         .object = false,
+        .@"struct" = false,
     };
 
     pub const any = Self{
@@ -34,6 +36,7 @@ pub const TypeSet = struct {
         .boolean = true,
         .array = true,
         .object = true,
+        .@"struct" = true,
     };
 
     void: bool,
@@ -42,6 +45,7 @@ pub const TypeSet = struct {
     boolean: bool,
     array: bool,
     object: bool,
+    @"struct": bool,
 
     pub fn from(value_type: Type) Self {
         return Self{
@@ -51,6 +55,7 @@ pub const TypeSet = struct {
             .boolean = (value_type == .boolean),
             .array = (value_type == .array),
             .object = (value_type == .object),
+            .@"struct" = (value_type == .@"struct"),
         };
     }
 
@@ -70,6 +75,7 @@ pub const TypeSet = struct {
             .boolean => self.boolean,
             .array => self.array,
             .object => self.object,
+            .@"struct" => self.@"struct",
         };
     }
 

src/library/libraries/stdlib.zig

@@ -603,6 +603,7 @@ pub fn TypeOf(env: *const lola.runtime.Environment, context: lola.runtime.Contex
         .object => "object",
         .array => "array",
         .enumerator => "enumerator",
+        .@"struct" => "struct",
     });
 }