enum Index [src]

Fields

root = 0
Members

get (Function)
getAstNode (Function)
Range (struct)
Source

  pub const Index = enum(u32) {
    root = 0,
    _,

    pub fn get(idx: Index, zoir: Zoir) Node {
        const repr = zoir.nodes.get(@intFromEnum(idx));
        return switch (repr.tag) {
            .true => .true,
            .false => .false,
            .null => .null,
            .pos_inf => .pos_inf,
            .neg_inf => .neg_inf,
            .nan => .nan,
            .int_literal_small => .{ .int_literal = .{ .small = @bitCast(repr.data) } },
            .int_literal_pos, .int_literal_neg => .{ .int_literal = .{ .big = .{
                .limbs = l: {
                    const limb_count, const limbs_idx = zoir.extra[repr.data..][0..2].*;
                    break :l zoir.limbs[limbs_idx..][0..limb_count];
                },
                .positive = switch (repr.tag) {
                    .int_literal_pos => true,
                    .int_literal_neg => false,
                    else => unreachable,
                },
            } } },
            .float_literal_small => .{ .float_literal = @as(f32, @bitCast(repr.data)) },
            .float_literal => .{ .float_literal = @bitCast(zoir.extra[repr.data..][0..4].*) },
            .char_literal => .{ .char_literal = @intCast(repr.data) },
            .enum_literal => .{ .enum_literal = @enumFromInt(repr.data) },
            .string_literal => .{ .string_literal = s: {
                const start, const len = zoir.extra[repr.data..][0..2].*;
                break :s zoir.string_bytes[start..][0..len];
            } },
            .string_literal_null => .{ .string_literal = NullTerminatedString.get(@enumFromInt(repr.data), zoir) },
            .empty_literal => .empty_literal,
            .array_literal => .{ .array_literal = a: {
                const elem_count, const first_elem = zoir.extra[repr.data..][0..2].*;
                break :a .{ .start = @enumFromInt(first_elem), .len = elem_count };
            } },
            .struct_literal => .{ .struct_literal = s: {
                const elem_count, const first_elem = zoir.extra[repr.data..][0..2].*;
                const field_names = zoir.extra[repr.data + 2 ..][0..elem_count];
                break :s .{
                    .names = @ptrCast(field_names),
                    .vals = .{ .start = @enumFromInt(first_elem), .len = elem_count },
                };
            } },
        };
    }

    pub fn getAstNode(idx: Index, zoir: Zoir) std.zig.Ast.Node.Index {
        return zoir.nodes.items(.ast_node)[@intFromEnum(idx)];
    }

    pub const Range = struct {
        start: Index,
        len: u32,

        pub fn at(r: Range, i: u32) Index {
            assert(i < r.len);
            return @enumFromInt(@intFromEnum(r.start) + i);
        }
    };
}  