createMacroFn

fn createMacroFn(mt: *MacroTranslator, name: []const u8, ref: ZigNode, proto_alias: *ast.Payload.Func) !ZigNode

File

Code

fn createMacroFn(mt: *MacroTranslator, name: []const u8, ref: ZigNode, proto_alias: *ast.Payload.Func) !ZigNode {
    const gpa = mt.t.gpa;
    const arena = mt.t.arena;
    var fn_params: std.ArrayList(ast.Payload.Param) = .empty;
    defer fn_params.deinit(gpa);

    var block_scope = try Scope.Block.init(mt.t, &mt.t.global_scope.base, false);
    defer block_scope.deinit();

    for (proto_alias.data.params) |param| {
        const param_name = try block_scope.makeMangledName(param.name orelse "arg");

        try fn_params.append(gpa, .{
            .name = param_name,
            .type = param.type,
            .is_noalias = param.is_noalias,
        });
    }

    const init = if (ref.castTag(.var_decl)) |v|
        v.data.init.?
    else if (ref.castTag(.var_simple) orelse ref.castTag(.pub_var_simple)) |v|
        v.data.init
    else
        unreachable;

    const unwrap_expr = try ZigTag.unwrap.create(arena, init);
    const args = try arena.alloc(ZigNode, fn_params.items.len);
    for (fn_params.items, 0..) |param, i| {
        args[i] = try ZigTag.identifier.create(arena, param.name.?);
    }
    const call_expr = try ZigTag.call.create(arena, .{
        .lhs = unwrap_expr,
        .args = args,
    });
    const return_expr = try ZigTag.@"return".create(arena, call_expr);
    const block = try ZigTag.block_single.create(arena, return_expr);

    return ZigTag.pub_inline_fn.create(arena, .{
        .name = name,
        .params = try arena.dupe(ast.Payload.Param, fn_params.items),
        .return_type = proto_alias.data.return_type,
        .body = block,
    });
}