arena

src/parser.zig

@@ -553,8 +553,25 @@ pub const Parser = struct {
         var field_names = std.ArrayList([]const u8).empty;
         var field_types = std.ArrayList(*Node).empty;
         var field_defaults = std.ArrayList(?*Node).empty;
+        var using_entries = std.ArrayList(ast.UsingEntry).empty;
 
         while (self.current.tag != .r_brace and self.current.tag != .eof) {
+            // Check for #using directive
+            if (self.current.tag == .hash_using) {
+                self.advance(); // skip #using
+                if (self.current.tag != .identifier) {
+                    return self.fail("expected type name after '#using'");
+                }
+                const used_type = self.tokenSlice(self.current);
+                self.advance();
+                try using_entries.append(self.allocator, .{
+                    .insert_index = @intCast(field_names.items.len),
+                    .type_name = used_type,
+                });
+                if (self.current.tag == .semicolon) self.advance();
+                continue;
+            }
+
             // Parse field group: name1, name2, ...: type (= default)?;
             var group_names = std.ArrayList([]const u8).empty;
 
@@ -607,6 +624,7 @@ pub const Parser = struct {
             .field_types = try field_types.toOwnedSlice(self.allocator),
             .field_defaults = try field_defaults.toOwnedSlice(self.allocator),
             .type_params = try type_params.toOwnedSlice(self.allocator),
+            .using_entries = try using_entries.toOwnedSlice(self.allocator),
         } });
     }
 
@@ -959,6 +977,9 @@ pub const Parser = struct {
             try self.expectSemicolonAfter(expr);
             return expr;
         }
+        if (self.current.tag == .kw_push) {
+            return try self.parsePushStmt();
+        }
 
         // Expression statement
         const expr = try self.parseExpr();
@@ -1326,6 +1347,9 @@ pub const Parser = struct {
             .kw_for => {
                 return self.parseForExpr();
             },
+            .kw_push => {
+                return self.parsePushStmt();
+            },
             .kw_break => {
                 self.advance();
                 return try self.createNode(start, .{ .break_expr = {} });
@@ -1473,6 +1497,19 @@ pub const Parser = struct {
         } });
     }
 
+    fn parsePushStmt(self: *Parser) anyerror!*Node {
+        const start = self.current.loc.start;
+        self.advance(); // skip 'push'
+
+        const context_expr = try self.parseExpr();
+        const body = try self.parseBlock();
+
+        return try self.createNode(start, .{ .push_stmt = .{
+            .context_expr = context_expr,
+            .body = body,
+        } });
+    }
+
     fn parseForExpr(self: *Parser) anyerror!*Node {
         const start = self.current.loc.start;
         self.advance(); // skip 'for'