013 generics star bracket requires params

// Test: [*] requires brackets — bare ring.new is 'unknown tor'
//
// Given: a tor declared `ring.new[*]` and an invocation spelled `ring.new`
// with no bracket tail — the marker means the parameterized form is the
// ONLY name it answers, so the bare call must refuse as an unknown tor
// rather than silently route to the transform with no params to parse.
// Pair: 700_012 pins the accept direction (ring.new[T:…] matches).
//
// Transform should:
// 1. Parse event_name to extract T=u32, N=1024
// 2. Use these to generate properly typed Zig code:
//
//    const counter_ring = struct {
//        buffer: [1024]u32 = undefined,
//        head: usize = 0,
//        tail: usize = 0,
//    };
//
// This is generics-as-library: the transform IS the generic instantiation.

~[comptime|transform]pub tor ring.new[*] {
    event_name: string,
    item: *const std/compiler:Item,
    program: *const std/compiler:Program,
} -> SiteResult

~proc ring.new[*]|zig {
    const std = @import("std");
    const ast = @import("ast");
    const allocator = std.heap.page_allocator;

    // Parse: ring.new[T:u32;N:1024]
    const bracket_start = std.mem.indexOf(u8, event_name, "[") orelse return .{};
    const bracket_end = std.mem.lastIndexOf(u8, event_name, "]") orelse return .{};

    const params_str = event_name[bracket_start + 1 .. bracket_end];

    // Simple parsing: split by semicolon, then by colon
    // "T:u32;N:1024" → T=u32, N=1024
    var T: []const u8 = "u8";
    var N: []const u8 = "64";

    var params_iter = std.mem.splitScalar(u8, params_str, ';');
    while (params_iter.next()) |param| {
        const trimmed = std.mem.trim(u8, param, " ");
        if (std.mem.indexOf(u8, trimmed, ":")) |colon| {
            const key = trimmed[0..colon];
            const value = trimmed[colon + 1 ..];
            if (std.mem.eql(u8, key, "T")) {
                T = value;
            } else if (std.mem.eql(u8, key, "N")) {
                N = value;
            }
        }
    }

    // Extract ring name: get command from "ring.new" then use it as default name
    const command_start: usize = 5; // Skip "ring."
    const command_end = bracket_start;
    const command = event_name[command_start..command_end];
    _ = command;
    const name = "my_ring"; // Hardcode for this test - getting name from args is separate feature

    // Generate typed ring struct
    const code = std.fmt.allocPrint(
        allocator,
        \\const {s} = struct {{
        \\    buffer: [{s}]{s} = undefined,
        \\    head: usize = 0,
        \\    tail: usize = 0,
        \\
        \\    pub fn enqueue(self: *@This(), item: {s}) void {{
        \\        self.buffer[self.tail] = item;
        \\        self.tail = (self.tail + 1) % {s};
        \\    }}
        \\}};
        ,
        .{ name, N, T, T, N }
    ) catch unreachable;

    const flow = if (item.* == .flow) &item.flow else return .{};

    const inline_code_item = ast.Item{
        .inline_code = ast.InlineCode{
            .code = code,
            .location = flow.location,
            .module = allocator.dupe(u8, flow.module) catch unreachable,
        },
    };

    return .{ .replacement = inline_code_item };
}

// Create a ring buffer of 1024 u32 values
~ring.new