srctree

.namespace, .enum_namespace => break,

.namespace, .enum_namespace => break,

.namespace, .enum_namespace => break,

.closure_get,

.closure_capture,

.namespace, .enum_namespace => unreachable,

.namespace, .enum_namespace => unreachable,

.namespace, .enum_namespace => unreachable,

defer {

astgen.fn_block = prev_fn_block;

astgen.fn_ret_ty = prev_fn_ret_ty;

}

.namespace, .enum_namespace => {

.backing_int_ref = .none,

.backing_int_body_len = 0,

.backing_int_ref = backing_int_ref,

.backing_int_body_len = @intCast(backing_int_body_len),

try astgen.extra.ensureUnusedCapacity(gpa, backing_int_body_len +

decls_slice.len + fields_slice.len + bodies_slice.len);

astgen.extra.appendSliceAssumeCapacity(astgen.scratch.items[scratch_top..][0..backing_int_body_len]);

try gz.addNamespaceCaptures(&namespace);

try astgen.extra.ensureUnusedCapacity(gpa, decls_slice.len + body_len + fields_slice.len);

try gz.addNamespaceCaptures(&namespace);

namespace.base.tag = .enum_namespace;

namespace.base.tag = .namespace;

namespace.base.tag = .enum_namespace;

try astgen.extra.ensureUnusedCapacity(gpa, decls_slice.len + body_len + fields_slice.len);

try gz.addNamespaceCaptures(&namespace);

try astgen.extra.ensureUnusedCapacity(gpa, decls_slice.len);

try gz.addNamespaceCaptures(&namespace);

const gpa = astgen.gpa;

var capturing_namespace: ?*Scope.Namespace = null;

const value_inst = try tunnelThroughClosure(

capturing_namespace,

local_val.inst,

local_val.token_src,

gpa,

);

try astgen.errNoteNode(capturing_namespace.?.node, "crosses namespace boundary here", .{}),

const ptr_inst = try tunnelThroughClosure(

capturing_namespace,

local_ptr.ptr,

local_ptr.token_src,

gpa,

);

.namespace, .enum_namespace => {

if (s.tag == .namespace) num_namespaces_out += 1;

/// Adds a capture to a namespace, if needed.

/// Returns the index of the closure_capture instruction.

ns: ?*Scope.Namespace,

value: Zir.Inst.Ref,

token: Ast.TokenIndex,

gpa: Allocator,

// For trivial values, we don't need a tunnel.

// Just return the ref.

if (num_tunnels == 0 or value.toIndex() == null) {

return value;

// Otherwise we need a tunnel. Check if this namespace

// already has one for this value.

const gop = try ns.?.captures.getOrPut(gpa, value.toIndex().?);

if (!gop.found_existing) {

// Make a new capture for this value but don't add it to the declaring_gz yet

try gz.astgen.instructions.append(gz.astgen.gpa, .{

.tag = .closure_capture,

.data = .{ .un_tok = .{

.operand = value,

.src_tok = ns.?.declaring_gz.?.tokenIndexToRelative(token),

} },

gop.value_ptr.* = @enumFromInt(gz.astgen.instructions.len - 1);

// Add an instruction to get the value from the closure into

// our current context

return try gz.addInstNode(.closure_get, gop.value_ptr.*, inner_ref_node);

.namespace, .enum_namespace => {

.namespace, .enum_namespace => return @fieldParentPtr(T, "base", base),

.namespace, .enum_namespace => base.cast(Namespace).?.parent,

enum_namespace,

/// Map from the raw captured value to the instruction

/// ref of the capture for decls in this namespace

captures: std.AutoArrayHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .{},

/// Namespace members are lazy. When executing a decl within a namespace,

/// any references to external instructions need to be treated specially.

/// This list tracks those references. See also .closure_capture and .closure_get.

/// Keys are the raw instruction index, values are the closure_capture instruction.

captures: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .{},

 

backing_int_ref: Zir.Inst.Ref,

backing_int_body_len: u32,

try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.StructDecl).Struct.fields.len + 4);

if (args.backing_int_ref != .none) {

astgen.extra.appendAssumeCapacity(args.backing_int_body_len);

if (args.backing_int_body_len == 0) {

astgen.extra.appendAssumeCapacity(@intFromEnum(args.backing_int_ref));

}

}

.has_backing_int = args.backing_int_ref != .none,

try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.UnionDecl).Struct.fields.len + 4);

try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.EnumDecl).Struct.fields.len + 4);

try astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.OpaqueDecl).Struct.fields.len + 1);

fn addNamespaceCaptures(gz: *GenZir, namespace: *Scope.Namespace) !void {

if (namespace.captures.count() > 0) {

try gz.instructions.ensureUnusedCapacity(gz.astgen.gpa, namespace.captures.count());

for (namespace.captures.values()) |capture| {

gz.instructions.appendAssumeCapacity(capture);

}

}

}

 

.namespace, .enum_namespace => {

.namespace, .enum_namespace => s = s.cast(Scope.Namespace).?.parent,

/// When a type or function refers to a comptime value from an outer

/// scope, that forms a closure over comptime value. The outer scope

/// will record a capture of that value, which encodes its current state

/// and marks it to persist. Uses `un_tok` field. Operand is the

/// instruction value to capture.

closure_capture,

/// The inner scope of a closure uses closure_get to retrieve the value

/// stored by the outer scope. Uses `inst_node` field. Operand is the

/// closure_capture instruction ref.

closure_get,

 

.closure_get,

.closure_capture,

.closure_get,

.closure_capture,

.closure_capture = .un_tok,

.closure_get = .inst_node,

 

capture: Capture,

/// 0. fields_len: u32, // if has_fields_len

/// 1. decls_len: u32, // if has_decls_len

/// 2. backing_int_body_len: u32, // if has_backing_int

/// 3. backing_int_ref: Ref, // if has_backing_int and backing_int_body_len is 0

/// 4. backing_int_body_inst: Inst, // if has_backing_int and backing_int_body_len is > 0

/// 5. decl: Index, // for every decls_len; points to a `declaration` instruction

/// 6. flags: u32 // for every 8 fields

/// 7. fields: { // for every fields_len

/// 8. bodies: { // for every fields_len

_: u3 = undefined,

/// 1. body_len: u32, // if has_body_len

/// 2. fields_len: u32, // if has_fields_len

/// 3. decls_len: u32, // if has_decls_len

/// 4. decl: Index, // for every decls_len; points to a `declaration` instruction

/// 5. inst: Index // for every body_len

/// 6. has_bits: u32 // for every 32 fields

/// 7. fields: { // for every fields_len

_: u9 = undefined,

/// 1. body_len: u32, // if has_body_len

/// 2. fields_len: u32, // if has_fields_len

/// 3. decls_len: u32, // if has_decls_len

/// 4. decl: Index, // for every decls_len; points to a `declaration` instruction

/// 5. inst: Index // for every body_len

/// 6. has_bits: u32 // for every 8 fields

/// 7. fields: { // for every fields_len

_: u6 = undefined,

/// 0. decls_len: u32, // if has_decls_len

/// 1. decl: Index, // for every decls_len; points to a `declaration` instruction

_: u13 = undefined,

 

.closure_get => {

const inst_node = data[@intFromEnum(inst)].inst_node;

 

const code = try self.getBlockSource(file, parent_src, inst_node.src_node);

const idx = self.comptime_exprs.items.len;

try self.exprs.append(self.arena, .{ .comptimeExpr = idx });

try self.comptime_exprs.append(self.arena, .{ .code = code });

 

return DocData.WalkResult{

.expr = .{ .comptimeExpr = idx },

};

},

.closure_capture => {

const un_tok = data[@intFromEnum(inst)].un_tok;

return try self.walkRef(

file,

parent_scope,

parent_src,

un_tok.operand,

need_type,

call_ctx,

);

},

//! * Module.Decl has a pointer to Module.CaptureScope

struct_type: StructType,

union_type: Key.UnionType,

opaque_type: OpaqueType,

enum_type: EnumType,

pub const OpaqueType = extern struct {

/// The Decl that corresponds to the opaque itself.

decl: DeclIndex,

/// Represents the declarations inside this opaque.

namespace: NamespaceIndex,

zir_index: TrackedInst.Index.Optional,

};

 

/// Although packed structs and non-packed structs are encoded differently,

/// this struct is used for both categories since they share some common

/// functionality.

pub const StructType = struct {

extra_index: u32,

/// `none` when the struct is `@TypeOf(.{})`.

decl: OptionalDeclIndex,

/// `none` when the struct has no declarations.

namespace: OptionalNamespaceIndex,

/// Index of the struct_decl ZIR instruction.

zir_index: TrackedInst.Index.Optional,

layout: std.builtin.Type.ContainerLayout,

field_names: NullTerminatedString.Slice,

field_types: Index.Slice,

field_inits: Index.Slice,

field_aligns: Alignment.Slice,

runtime_order: RuntimeOrder.Slice,

comptime_bits: ComptimeBits,

offsets: Offsets,

names_map: OptionalMapIndex,

 

pub const ComptimeBits = struct {

start: u32,

/// This is the number of u32 elements, not the number of struct fields.

len: u32,

 

pub fn get(this: @This(), ip: *const InternPool) []u32 {

return ip.extra.items[this.start..][0..this.len];

}

 

pub fn getBit(this: @This(), ip: *const InternPool, i: usize) bool {

if (this.len == 0) return false;

return @as(u1, @truncate(this.get(ip)[i / 32] >> @intCast(i % 32))) != 0;

}

 

pub fn setBit(this: @This(), ip: *const InternPool, i: usize) void {

this.get(ip)[i / 32] |= @as(u32, 1) << @intCast(i % 32);

}

 

pub fn clearBit(this: @This(), ip: *const InternPool, i: usize) void {

this.get(ip)[i / 32] &= ~(@as(u32, 1) << @intCast(i % 32));

}

};

 

pub const Offsets = struct {

start: u32,

len: u32,

 

pub fn get(this: @This(), ip: *const InternPool) []u32 {

return @ptrCast(ip.extra.items[this.start..][0..this.len]);

}

};

 

pub const RuntimeOrder = enum(u32) {

/// Placeholder until layout is resolved.

unresolved = std.math.maxInt(u32) - 0,

/// Field not present at runtime

omitted = std.math.maxInt(u32) - 1,

_,

 

pub const Slice = struct {

start: u32,

len: u32,

 

pub fn get(slice: RuntimeOrder.Slice, ip: *const InternPool) []RuntimeOrder {

return @ptrCast(ip.extra.items[slice.start..][0..slice.len]);

}

};

 

pub fn toInt(i: @This()) ?u32 {

return switch (i) {

.omitted => null,

.unresolved => unreachable,

else => @intFromEnum(i),

};

}

};

 

/// Look up field index based on field name.

pub fn nameIndex(self: StructType, ip: *const InternPool, name: NullTerminatedString) ?u32 {

const names_map = self.names_map.unwrap() orelse {

const i = name.toUnsigned(ip) orelse return null;

if (i >= self.field_types.len) return null;

return i;

};

const map = &ip.maps.items[@intFromEnum(names_map)];

const adapter: NullTerminatedString.Adapter = .{ .strings = self.field_names.get(ip) };

const field_index = map.getIndexAdapted(name, adapter) orelse return null;

return @intCast(field_index);

}

 

/// Returns the already-existing field with the same name, if any.

pub fn addFieldName(

self: @This(),

ip: *InternPool,

name: NullTerminatedString,

) ?u32 {

return ip.addFieldName(self.names_map.unwrap().?, self.field_names.start, name);

}

 

pub fn fieldAlign(s: @This(), ip: *const InternPool, i: usize) Alignment {

if (s.field_aligns.len == 0) return .none;

return s.field_aligns.get(ip)[i];

}

 

pub fn fieldInit(s: @This(), ip: *const InternPool, i: usize) Index {

if (s.field_inits.len == 0) return .none;

assert(s.haveFieldInits(ip));

return s.field_inits.get(ip)[i];

}

 

/// Returns `none` in the case the struct is a tuple.

pub fn fieldName(s: @This(), ip: *const InternPool, i: usize) OptionalNullTerminatedString {

if (s.field_names.len == 0) return .none;

return s.field_names.get(ip)[i].toOptional();

}

 

pub fn fieldIsComptime(s: @This(), ip: *const InternPool, i: usize) bool {

return s.comptime_bits.getBit(ip, i);

}

 

pub fn setFieldComptime(s: @This(), ip: *InternPool, i: usize) void {

s.comptime_bits.setBit(ip, i);

}

 

/// Reads the non-opv flag calculated during AstGen. Used to short-circuit more

/// complicated logic.

pub fn knownNonOpv(s: @This(), ip: *InternPool) bool {

return switch (s.layout) {

.Packed => false,

.Auto, .Extern => s.flagsPtr(ip).known_non_opv,

};

}

 

/// The returned pointer expires with any addition to the `InternPool`.

/// Asserts the struct is not packed.

pub fn flagsPtr(self: @This(), ip: *const InternPool) *Tag.TypeStruct.Flags {

assert(self.layout != .Packed);

const flags_field_index = std.meta.fieldIndex(Tag.TypeStruct, "flags").?;

return @ptrCast(&ip.extra.items[self.extra_index + flags_field_index]);

}

 

/// The returned pointer expires with any addition to the `InternPool`.

/// Asserts that the struct is packed.

pub fn packedFlagsPtr(self: @This(), ip: *const InternPool) *Tag.TypeStructPacked.Flags {

assert(self.layout == .Packed);

const flags_field_index = std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?;

return @ptrCast(&ip.extra.items[self.extra_index + flags_field_index]);

}

 

pub fn assumeRuntimeBitsIfFieldTypesWip(s: @This(), ip: *InternPool) bool {

if (s.layout == .Packed) return false;

const flags_ptr = s.flagsPtr(ip);

if (flags_ptr.field_types_wip) {

flags_ptr.assumed_runtime_bits = true;

return true;

}

return false;

}

 

pub fn setTypesWip(s: @This(), ip: *InternPool) bool {

if (s.layout == .Packed) return false;

const flags_ptr = s.flagsPtr(ip);

if (flags_ptr.field_types_wip) return true;

flags_ptr.field_types_wip = true;

return false;

}

 

pub fn clearTypesWip(s: @This(), ip: *InternPool) void {

if (s.layout == .Packed) return;

s.flagsPtr(ip).field_types_wip = false;

}

 

pub fn setLayoutWip(s: @This(), ip: *InternPool) bool {

if (s.layout == .Packed) return false;

const flags_ptr = s.flagsPtr(ip);

if (flags_ptr.layout_wip) return true;

flags_ptr.layout_wip = true;

return false;

}

 

pub fn clearLayoutWip(s: @This(), ip: *InternPool) void {

if (s.layout == .Packed) return;

s.flagsPtr(ip).layout_wip = false;

}

 

pub fn setAlignmentWip(s: @This(), ip: *InternPool) bool {

if (s.layout == .Packed) return false;

const flags_ptr = s.flagsPtr(ip);

if (flags_ptr.alignment_wip) return true;

flags_ptr.alignment_wip = true;

return false;

}

 

pub fn clearAlignmentWip(s: @This(), ip: *InternPool) void {

if (s.layout == .Packed) return;

s.flagsPtr(ip).alignment_wip = false;

}

 

pub fn setInitsWip(s: @This(), ip: *InternPool) bool {

switch (s.layout) {

.Packed => {

const flag = &s.packedFlagsPtr(ip).field_inits_wip;

if (flag.*) return true;

flag.* = true;

return false;

},

.Auto, .Extern => {

const flag = &s.flagsPtr(ip).field_inits_wip;

if (flag.*) return true;

flag.* = true;

return false;

},

}

}

 

pub fn clearInitsWip(s: @This(), ip: *InternPool) void {

switch (s.layout) {

.Packed => s.packedFlagsPtr(ip).field_inits_wip = false,

.Auto, .Extern => s.flagsPtr(ip).field_inits_wip = false,

}

}

 

pub fn setFullyResolved(s: @This(), ip: *InternPool) bool {

if (s.layout == .Packed) return true;

const flags_ptr = s.flagsPtr(ip);

if (flags_ptr.fully_resolved) return true;

flags_ptr.fully_resolved = true;

return false;

}

 

pub fn clearFullyResolved(s: @This(), ip: *InternPool) void {

s.flagsPtr(ip).fully_resolved = false;

}

 

/// The returned pointer expires with any addition to the `InternPool`.

/// Asserts the struct is not packed.

pub fn size(self: @This(), ip: *InternPool) *u32 {

assert(self.layout != .Packed);

const size_field_index = std.meta.fieldIndex(Tag.TypeStruct, "size").?;

return @ptrCast(&ip.extra.items[self.extra_index + size_field_index]);

}

 

/// The backing integer type of the packed struct. Whether zig chooses

/// this type or the user specifies it, it is stored here. This will be

/// set to `none` until the layout is resolved.

/// Asserts the struct is packed.

pub fn backingIntType(s: @This(), ip: *const InternPool) *Index {

assert(s.layout == .Packed);

const field_index = std.meta.fieldIndex(Tag.TypeStructPacked, "backing_int_ty").?;

return @ptrCast(&ip.extra.items[s.extra_index + field_index]);

}

 

/// Asserts the struct is not packed.

pub fn setZirIndex(s: @This(), ip: *InternPool, new_zir_index: TrackedInst.Index.Optional) void {

assert(s.layout != .Packed);

const field_index = std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?;

ip.extra.items[s.extra_index + field_index] = @intFromEnum(new_zir_index);

}

 

pub fn haveFieldTypes(s: @This(), ip: *const InternPool) bool {

const types = s.field_types.get(ip);

return types.len == 0 or types[0] != .none;

}

 

pub fn haveFieldInits(s: @This(), ip: *const InternPool) bool {

return switch (s.layout) {

.Packed => s.packedFlagsPtr(ip).inits_resolved,

.Auto, .Extern => s.flagsPtr(ip).inits_resolved,

};

}

 

pub fn setHaveFieldInits(s: @This(), ip: *InternPool) void {

switch (s.layout) {

.Packed => s.packedFlagsPtr(ip).inits_resolved = true,

.Auto, .Extern => s.flagsPtr(ip).inits_resolved = true,

}

}

 

pub fn haveLayout(s: @This(), ip: *InternPool) bool {

return switch (s.layout) {

.Packed => s.backingIntType(ip).* != .none,

.Auto, .Extern => s.flagsPtr(ip).layout_resolved,

};

}

 

pub fn isTuple(s: @This(), ip: *InternPool) bool {

return s.layout != .Packed and s.flagsPtr(ip).is_tuple;

}

 

pub fn hasReorderedFields(s: @This()) bool {

return s.layout == .Auto;

}

 

pub const RuntimeOrderIterator = struct {

ip: *InternPool,

field_index: u32,

struct_type: InternPool.Key.StructType,

 

pub fn next(it: *@This()) ?u32 {

var i = it.field_index;

 

if (i >= it.struct_type.field_types.len)

return null;

 

if (it.struct_type.hasReorderedFields()) {

it.field_index += 1;

return it.struct_type.runtime_order.get(it.ip)[i].toInt();

}

 

while (it.struct_type.fieldIsComptime(it.ip, i)) {

i += 1;

if (i >= it.struct_type.field_types.len)

return null;

}

 

it.field_index = i + 1;

return i;

}

};

 

/// Iterates over non-comptime fields in the order they are laid out in memory at runtime.

/// May or may not include zero-bit fields.

/// Asserts the struct is not packed.

pub fn iterateRuntimeOrder(s: @This(), ip: *InternPool) RuntimeOrderIterator {

assert(s.layout != .Packed);

return .{

.ip = ip,

.field_index = 0,

.struct_type = s,

};

}

};

 

/// Serves two purposes:

/// * Being the key in the InternPool hash map, which only requires the `decl` field.

/// * Provide the other fields that do not require chasing the enum type.

pub const UnionType = struct {

/// The Decl that corresponds to the union itself.

decl: DeclIndex,

/// The index of the `Tag.TypeUnion` payload. Ignored by `get`,

/// populated by `indexToKey`.

extra_index: u32,

namespace: NamespaceIndex,

flags: Tag.TypeUnion.Flags,

/// The enum that provides the list of field names and values.

enum_tag_ty: Index,

zir_index: TrackedInst.Index.Optional,

 

/// The returned pointer expires with any addition to the `InternPool`.

pub fn flagsPtr(self: @This(), ip: *const InternPool) *Tag.TypeUnion.Flags {

const flags_field_index = std.meta.fieldIndex(Tag.TypeUnion, "flags").?;

return @ptrCast(&ip.extra.items[self.extra_index + flags_field_index]);

}

 

/// The returned pointer expires with any addition to the `InternPool`.

pub fn size(self: @This(), ip: *InternPool) *u32 {

const size_field_index = std.meta.fieldIndex(Tag.TypeUnion, "size").?;

return &ip.extra.items[self.extra_index + size_field_index];

}

 

/// The returned pointer expires with any addition to the `InternPool`.

pub fn padding(self: @This(), ip: *InternPool) *u32 {

const padding_field_index = std.meta.fieldIndex(Tag.TypeUnion, "padding").?;

return &ip.extra.items[self.extra_index + padding_field_index];

}

 

pub fn haveFieldTypes(self: @This(), ip: *const InternPool) bool {

return self.flagsPtr(ip).status.haveFieldTypes();

}

 

pub fn hasTag(self: @This(), ip: *const InternPool) bool {

return self.flagsPtr(ip).runtime_tag.hasTag();

}

 

pub fn getLayout(self: @This(), ip: *const InternPool) std.builtin.Type.ContainerLayout {

return self.flagsPtr(ip).layout;

}

 

pub fn haveLayout(self: @This(), ip: *const InternPool) bool {

return self.flagsPtr(ip).status.haveLayout();

}

 

/// Pointer to an enum type which is used for the tag of the union.

/// This type is created even for untagged unions, even when the memory

/// layout does not store the tag.

/// Whether zig chooses this type or the user specifies it, it is stored here.

/// This will be set to the null type until status is `have_field_types`.

/// This accessor is provided so that the tag type can be mutated, and so that

/// when it is mutated, the mutations are observed.

/// The returned pointer is invalidated when something is added to the `InternPool`.

pub fn tagTypePtr(self: @This(), ip: *const InternPool) *Index {

const tag_ty_field_index = std.meta.fieldIndex(Tag.TypeUnion, "tag_ty").?;

return @ptrCast(&ip.extra.items[self.extra_index + tag_ty_field_index]);

}

 

pub fn setFieldTypes(self: @This(), ip: *InternPool, types: []const Index) void {

@memcpy((Index.Slice{

.start = @intCast(self.extra_index + @typeInfo(Tag.TypeUnion).Struct.fields.len),

.len = @intCast(types.len),

}).get(ip), types);

}

 

pub fn setFieldAligns(self: @This(), ip: *InternPool, aligns: []const Alignment) void {

if (aligns.len == 0) return;

assert(self.flagsPtr(ip).any_aligned_fields);

@memcpy((Alignment.Slice{

.start = @intCast(

self.extra_index + @typeInfo(Tag.TypeUnion).Struct.fields.len + aligns.len,

),

.len = @intCast(aligns.len),

}).get(ip), aligns);

}

};

 

pub const EnumType = struct {

/// The Decl that corresponds to the enum itself.

decl: DeclIndex,

/// Represents the declarations inside this enum.

namespace: OptionalNamespaceIndex,

/// An integer type which is used for the numerical value of the enum.

/// This field is present regardless of whether the enum has an

/// explicitly provided tag type or auto-numbered.

tag_ty: Index,

/// Set of field names in declaration order.

names: NullTerminatedString.Slice,

/// Maps integer tag value to field index.

/// Entries are in declaration order, same as `fields`.

/// If this is empty, it means the enum tags are auto-numbered.

values: Index.Slice,

tag_mode: TagMode,

/// This is ignored by `get` but will always be provided by `indexToKey`.

names_map: OptionalMapIndex = .none,

/// This is ignored by `get` but will be provided by `indexToKey` when

/// a value map exists.

values_map: OptionalMapIndex = .none,

zir_index: TrackedInst.Index.Optional,

 

pub const TagMode = enum {

/// The integer tag type was auto-numbered by zig.

auto,

/// The integer tag type was provided by the enum declaration, and the enum

/// is exhaustive.

explicit,

/// The integer tag type was provided by the enum declaration, and the enum

/// is non-exhaustive.

nonexhaustive,

};

 

/// Look up field index based on field name.

pub fn nameIndex(self: EnumType, ip: *const InternPool, name: NullTerminatedString) ?u32 {

const map = &ip.maps.items[@intFromEnum(self.names_map.unwrap().?)];

const adapter: NullTerminatedString.Adapter = .{ .strings = self.names.get(ip) };

const field_index = map.getIndexAdapted(name, adapter) orelse return null;

return @intCast(field_index);

}

 

/// Look up field index based on tag value.

/// Asserts that `values_map` is not `none`.

/// This function returns `null` when `tag_val` does not have the

/// integer tag type of the enum.

pub fn tagValueIndex(self: EnumType, ip: *const InternPool, tag_val: Index) ?u32 {

assert(tag_val != .none);

// TODO: we should probably decide a single interface for this function, but currently

// it's being called with both tag values and underlying ints. Fix this!

const int_tag_val = switch (ip.indexToKey(tag_val)) {

.enum_tag => |enum_tag| enum_tag.int,

.int => tag_val,

else => unreachable,

};

if (self.values_map.unwrap()) |values_map| {

const map = &ip.maps.items[@intFromEnum(values_map)];

const adapter: Index.Adapter = .{ .indexes = self.values.get(ip) };

const field_index = map.getIndexAdapted(int_tag_val, adapter) orelse return null;

return @intCast(field_index);

}

// Auto-numbered enum. Convert `int_tag_val` to field index.

const field_index = switch (ip.indexToKey(int_tag_val).int.storage) {

inline .u64, .i64 => |x| std.math.cast(u32, x) orelse return null,

.big_int => |x| x.to(u32) catch return null,

.lazy_align, .lazy_size => unreachable,

};

return if (field_index < self.names.len) field_index else null;

}

};

 

pub const IncompleteEnumType = struct {

/// Same as corresponding `EnumType` field.

decl: DeclIndex,

/// Same as corresponding `EnumType` field.

namespace: OptionalNamespaceIndex,

/// The field names and field values are not known yet, but

/// the number of fields must be known ahead of time.

fields_len: u32,

/// This information is needed so that the size does not change

/// later when populating field values.

has_values: bool,

/// Same as corresponding `EnumType` field.

tag_mode: EnumType.TagMode,

/// This may be updated via `setTagType` later.

tag_ty: Index = .none,

zir_index: TrackedInst.Index.Optional,

 

pub fn toEnumType(self: @This()) EnumType {

return .{

.decl = self.decl,

.namespace = self.namespace,

.tag_ty = self.tag_ty,

.tag_mode = self.tag_mode,

.names = .{ .start = 0, .len = 0 },

.values = .{ .start = 0, .len = 0 },

.zir_index = self.zir_index,

};

}

 

/// Only the decl is used for hashing and equality, so we can construct

/// this minimal key for use with `map`.

pub fn toKey(self: @This()) Key {

return .{ .enum_type = self.toEnumType() };

}

inline .opaque_type,

.variable,

=> |x| Hash.hash(seed, asBytes(&x.decl)),

.opaque_type => |a_info| {

const b_info = b.opaque_type;

return a_info.decl == b_info.decl;

},

.enum_type => |a_info| {

const b_info = b.enum_type;

return a_info.decl == b_info.decl;

},

.union_type => |a_info| {

const b_info = b.union_type;

return a_info.decl == b_info.decl;

},

.struct_type => |a_info| {

const b_info = b.struct_type;

return a_info.decl == b_info.decl;

pub const UnionType = struct {

namespace: NamespaceIndex,

/// The integer tag type of the enum.

int_tag_ty: Index,

/// ABI size of the union, including padding

size: u64,

/// Trailing padding bytes

padding: u32,

/// List of field names in declaration order.

field_names: NullTerminatedString.Slice,

/// Index of the union_decl ZIR instruction.

zir_index: TrackedInst.Index.Optional,

/// Index into extra array of the `flags` field.

flags_index: u32,

/// Copied from `enum_tag_ty`.

names_map: OptionalMapIndex,

pub fn flagsPtr(self: UnionType, ip: *const InternPool) *Tag.TypeUnion.Flags {

return @ptrCast(&ip.extra.items[self.flags_index]);

/// Look up field index based on field name.

pub fn nameIndex(self: UnionType, ip: *const InternPool, name: NullTerminatedString) ?u32 {

const map = &ip.maps.items[@intFromEnum(self.names_map.unwrap().?)];

const adapter: NullTerminatedString.Adapter = .{ .strings = self.field_names.get(ip) };

const field_index = map.getIndexAdapted(name, adapter) orelse return null;

return @intCast(field_index);

pub fn hasTag(self: UnionType, ip: *const InternPool) bool {

pub fn haveFieldTypes(self: UnionType, ip: *const InternPool) bool {

pub fn haveLayout(self: UnionType, ip: *const InternPool) bool {

pub fn getLayout(self: UnionType, ip: *const InternPool) std.builtin.Type.ContainerLayout {

pub fn fieldAlign(self: UnionType, ip: *const InternPool, field_index: u32) Alignment {

/// This does not mutate the field of UnionType.

pub fn setZirIndex(self: @This(), ip: *InternPool, new_zir_index: TrackedInst.Index.Optional) void {

/// Fetch all the interesting fields of a union type into a convenient data

/// structure.

/// This asserts that the union's enum tag type has been resolved.

pub fn loadUnionType(ip: *InternPool, key: Key.UnionType) UnionType {

const type_union = ip.extraDataTrail(Tag.TypeUnion, key.extra_index);

const enum_ty = type_union.data.tag_ty;

const enum_info = ip.indexToKey(enum_ty).enum_type;

const fields_len: u32 = @intCast(enum_info.names.len);

.enum_tag_ty = enum_ty,

.int_tag_ty = enum_info.tag_ty,

.size = type_union.data.size,

.padding = type_union.data.padding,

.field_names = enum_info.names,

.names_map = enum_info.names_map,

.field_types = .{

.start = type_union.end,

.len = fields_len,

},

.field_aligns = .{

.start = type_union.end + fields_len,

.len = if (type_union.data.flags.any_aligned_fields) fields_len else 0,

},

.flags_index = key.extra_index + std.meta.fieldIndex(Tag.TypeUnion, "flags").?,

type_opaque: struct { data: *Key.OpaqueType },

type_struct_ns: struct { data: NamespaceIndex },

/// data is index of Key.OpaqueType in extra.

/// A non-packed struct type that has only a namespace; no fields.

/// data is NamespaceIndex.

type_struct_ns,

const OpaqueType = Key.OpaqueType;

.type_opaque => OpaqueType,

.type_struct_ns => unreachable,

/// The number of fields is provided by the `tag_ty` field.

/// 0. field type: Index for each field; declaration order

/// 1. field align: Alignment for each field; declaration order

namespace: NamespaceIndex,

zir_index: TrackedInst.Index.Optional,

runtime_tag: UnionType.RuntimeTag,

status: UnionType.Status,

_: u14 = 0,

/// 0. type: Index for each fields_len

/// 1. name: NullTerminatedString for each fields_len

/// 2. init: Index for each fields_len // if tag is type_struct_packed_inits

zir_index: TrackedInst.Index.Optional,

_: u30 = 0,

/// 0. type: Index for each field in declared order

/// 1. if not is_tuple:

/// 2. if any_default_inits:

/// 3. if has_namespace:

/// 4. if any_aligned_fields:

/// 5. if any_comptime_fields:

/// 6. if not is_extern:

/// 7. field_offset: u32 // for each field in declared order, undef until layout_resolved

zir_index: TrackedInst.Index.Optional,

 

_: u8 = 0,

/// 0. field name: NullTerminatedString for each fields_len; declaration order

/// 1. tag value: Index for each fields_len; declaration order

/// 0. field name: NullTerminatedString for each fields_len; declaration order

.type_opaque => .{ .opaque_type = ip.extraData(Key.OpaqueType, data) },

.type_struct => .{ .struct_type = if (data == 0) .{

.extra_index = 0,

.namespace = .none,

.decl = .none,

.zir_index = undefined,

.layout = .Auto,

.field_names = .{ .start = 0, .len = 0 },

.field_types = .{ .start = 0, .len = 0 },

.field_inits = .{ .start = 0, .len = 0 },

.field_aligns = .{ .start = 0, .len = 0 },

.runtime_order = .{ .start = 0, .len = 0 },

.comptime_bits = .{ .start = 0, .len = 0 },

.offsets = .{ .start = 0, .len = 0 },

.names_map = undefined,

} else extraStructType(ip, data) },

.type_struct_ns => .{ .struct_type = .{

.extra_index = 0,

.namespace = @as(NamespaceIndex, @enumFromInt(data)).toOptional(),

.decl = .none,

.zir_index = undefined,

.layout = .Auto,

.field_names = .{ .start = 0, .len = 0 },

.field_types = .{ .start = 0, .len = 0 },

.field_inits = .{ .start = 0, .len = 0 },

.field_aligns = .{ .start = 0, .len = 0 },

.runtime_order = .{ .start = 0, .len = 0 },

.comptime_bits = .{ .start = 0, .len = 0 },

.offsets = .{ .start = 0, .len = 0 },

.names_map = undefined,

.type_struct_packed => .{ .struct_type = extraPackedStructType(ip, data, false) },

.type_struct_packed_inits => .{ .struct_type = extraPackedStructType(ip, data, true) },

.type_union => .{ .union_type = extraUnionType(ip, data) },

 

.type_enum_auto => {

const enum_auto = ip.extraDataTrail(EnumAuto, data);

return .{ .enum_type = .{

.decl = enum_auto.data.decl,

.namespace = enum_auto.data.namespace,

.tag_ty = enum_auto.data.int_tag_type,

.names = .{

.start = @intCast(enum_auto.end),

.len = enum_auto.data.fields_len,

},

.values = .{

.start = 0,

.len = 0,

},

.tag_mode = .auto,

.names_map = enum_auto.data.names_map.toOptional(),

.values_map = .none,

.zir_index = enum_auto.data.zir_index,

},

.type_enum_explicit => ip.indexToKeyEnum(data, .explicit),

.type_enum_nonexhaustive => ip.indexToKeyEnum(data, .nonexhaustive),

.type_struct_ns,

.type_struct => {

const info = extraStructType(ip, ty_item.data);

return .{ .aggregate = .{

.ty = ty,

.storage = .{ .elems = @ptrCast(info.field_inits.get(ip)) },

} };

},

 

.type_struct_packed_inits => {

const info = extraPackedStructType(ip, ty_item.data, true);

fn extraUnionType(ip: *const InternPool, extra_index: u32) Key.UnionType {

const type_union = ip.extraData(Tag.TypeUnion, extra_index);

return .{

.decl = type_union.decl,

.namespace = type_union.namespace,

.flags = type_union.flags,

.enum_tag_ty = type_union.tag_ty,

.zir_index = type_union.zir_index,

.extra_index = extra_index,

};

}

 

fn extraStructType(ip: *const InternPool, extra_index: u32) Key.StructType {

const s = ip.extraDataTrail(Tag.TypeStruct, extra_index);

const fields_len = s.data.fields_len;

 

var index = s.end;

 

const field_types = t: {

const types: Index.Slice = .{ .start = index, .len = fields_len };

index += fields_len;

break :t types;

};

const names_map, const field_names: NullTerminatedString.Slice = t: {

if (s.data.flags.is_tuple) break :t .{ .none, .{ .start = 0, .len = 0 } };

const names_map: MapIndex = @enumFromInt(ip.extra.items[index]);

index += 1;

const names: NullTerminatedString.Slice = .{ .start = index, .len = fields_len };

index += fields_len;

break :t .{ names_map.toOptional(), names };

};

const field_inits: Index.Slice = t: {

if (!s.data.flags.any_default_inits) break :t .{ .start = 0, .len = 0 };

const inits: Index.Slice = .{ .start = index, .len = fields_len };

index += fields_len;

break :t inits;

};

const namespace = t: {

if (!s.data.flags.has_namespace) break :t .none;

const namespace: NamespaceIndex = @enumFromInt(ip.extra.items[index]);

index += 1;

break :t namespace.toOptional();

};

const field_aligns: Alignment.Slice = t: {

if (!s.data.flags.any_aligned_fields) break :t .{ .start = 0, .len = 0 };

const aligns: Alignment.Slice = .{ .start = index, .len = fields_len };

index += (fields_len + 3) / 4;

break :t aligns;

};

const comptime_bits: Key.StructType.ComptimeBits = t: {

if (!s.data.flags.any_comptime_fields) break :t .{ .start = 0, .len = 0 };

const comptime_bits: Key.StructType.ComptimeBits = .{ .start = index, .len = fields_len };

index += (fields_len + 31) / 32;

break :t comptime_bits;

};

const runtime_order: Key.StructType.RuntimeOrder.Slice = t: {

if (s.data.flags.is_extern) break :t .{ .start = 0, .len = 0 };

const ro: Key.StructType.RuntimeOrder.Slice = .{ .start = index, .len = fields_len };

index += fields_len;

break :t ro;

};

const offsets = t: {

const offsets: Key.StructType.Offsets = .{ .start = index, .len = fields_len };

index += fields_len;

break :t offsets;

};

return .{

.extra_index = extra_index,

.decl = s.data.decl.toOptional(),

.zir_index = s.data.zir_index,

.layout = if (s.data.flags.is_extern) .Extern else .Auto,

.field_types = field_types,

.names_map = names_map,

.field_names = field_names,

.field_inits = field_inits,

.namespace = namespace,

.field_aligns = field_aligns,

.comptime_bits = comptime_bits,

.runtime_order = runtime_order,

.offsets = offsets,

};

}

 

fn extraPackedStructType(ip: *const InternPool, extra_index: u32, inits: bool) Key.StructType {

const type_struct_packed = ip.extraDataTrail(Tag.TypeStructPacked, extra_index);

const fields_len = type_struct_packed.data.fields_len;

return .{

.extra_index = extra_index,

.decl = type_struct_packed.data.decl.toOptional(),

.namespace = type_struct_packed.data.namespace,

.zir_index = type_struct_packed.data.zir_index,

.layout = .Packed,

.field_types = .{

.start = type_struct_packed.end,

.len = fields_len,

},

.field_names = .{

.start = type_struct_packed.end + fields_len,

.len = fields_len,

},

.field_inits = if (inits) .{

.start = type_struct_packed.end + fields_len * 2,

.len = fields_len,

} else .{

.start = 0,

.len = 0,

},

.field_aligns = .{ .start = 0, .len = 0 },

.runtime_order = .{ .start = 0, .len = 0 },

.comptime_bits = .{ .start = 0, .len = 0 },

.offsets = .{ .start = 0, .len = 0 },

.names_map = type_struct_packed.data.names_map.toOptional(),

};

}

 

fn indexToKeyEnum(ip: *const InternPool, data: u32, tag_mode: Key.EnumType.TagMode) Key {

const enum_explicit = ip.extraDataTrail(EnumExplicit, data);

const fields_len = enum_explicit.data.fields_len;

return .{ .enum_type = .{

.decl = enum_explicit.data.decl,

.namespace = enum_explicit.data.namespace,

.tag_ty = enum_explicit.data.int_tag_type,

.names = .{

.start = @intCast(enum_explicit.end),

.len = fields_len,

},

.values = .{

.start = @intCast(enum_explicit.end + fields_len),

.len = if (enum_explicit.data.values_map != .none) fields_len else 0,

},

.tag_mode = tag_mode,

.names_map = enum_explicit.data.names_map.toOptional(),

.values_map = enum_explicit.data.values_map,

.zir_index = enum_explicit.data.zir_index,

} };

}

 

.opaque_type => |opaque_type| {

ip.items.appendAssumeCapacity(.{

.tag = .type_opaque,

.data = try ip.addExtra(gpa, opaque_type),

});

},

 

.enum_type => unreachable, // use getEnum() or getIncompleteEnum() instead

.struct_type => |struct_type| {

assert(base_index.index < struct_type.field_types.len);

.union_type => |union_key| {

const union_type = ip.loadUnionType(union_key);

assert(base_index.index < union_type.field_names.len);

.enum_type => |enum_type| assert(ip.typeOf(enum_tag.int) == enum_type.tag_ty),

.struct_type => |t| {

for (aggregate.storage.values(), t.field_types.get(ip)) |elem, field_ty| {

flags: Tag.TypeUnion.Flags,

decl: DeclIndex,

namespace: NamespaceIndex,

zir_index: TrackedInst.Index.Optional,

pub fn getUnionType(ip: *InternPool, gpa: Allocator, ini: UnionTypeInit) Allocator.Error!Index {

const prev_extra_len = ip.extra.items.len;

const union_type_extra_index = ip.addExtraAssumeCapacity(Tag.TypeUnion{

.flags = ini.flags,

.decl = ini.decl,

.namespace = ini.namespace,

.zir_index = ini.zir_index,

const adapter: KeyAdapter = .{ .intern_pool = ip };

const gop = try ip.map.getOrPutAdapted(gpa, Key{

.union_type = extraUnionType(ip, union_type_extra_index),

}, adapter);

if (gop.found_existing) {

ip.extra.items.len = prev_extra_len;

return @enumFromInt(gop.index);

}

 

ip.items.appendAssumeCapacity(.{

.tag = .type_union,

.data = union_type_extra_index,

});

return @enumFromInt(ip.items.len - 1);

decl: DeclIndex,

namespace: OptionalNamespaceIndex,

zir_index: TrackedInst.Index.Optional,

) Allocator.Error!Index {

const key: Key = .{

.struct_type = .{

// Only the decl matters for hashing and equality purposes.

.decl = ini.decl.toOptional(),

 

.extra_index = undefined,

.namespace = undefined,

.zir_index = undefined,

.layout = undefined,

.field_names = undefined,

.field_types = undefined,

.field_inits = undefined,

.field_aligns = undefined,

.runtime_order = undefined,

.comptime_bits = undefined,

.offsets = undefined,

.names_map = undefined,

},

};

if (gop.found_existing) return @enumFromInt(gop.index);

.data = ip.addExtraAssumeCapacity(Tag.TypeStructPacked{

.decl = ini.decl,

.zir_index = ini.zir_index,

.fields_len = ini.fields_len,

.namespace = ini.namespace,

.backing_int_ty = .none,

.names_map = names_map,

.flags = .{

.field_inits_wip = false,

.inits_resolved = ini.inits_resolved,

},

}),

return @enumFromInt(ip.items.len - 1);

.data = ip.addExtraAssumeCapacity(Tag.TypeStruct{

.decl = ini.decl,

.zir_index = ini.zir_index,

.fields_len = ini.fields_len,

.size = std.math.maxInt(u32),

.flags = .{

.is_extern = is_extern,

.known_non_opv = ini.known_non_opv,

.requires_comptime = ini.requires_comptime,

.is_tuple = ini.is_tuple,

.assumed_runtime_bits = false,

.assumed_pointer_aligned = false,

.has_namespace = ini.namespace != .none,

.any_comptime_fields = ini.any_comptime_fields,

.any_default_inits = ini.any_default_inits,

.any_aligned_fields = ini.any_aligned_fields,

.alignment = .none,

.alignment_wip = false,

.field_types_wip = false,

.layout_wip = false,

.layout_resolved = false,

.field_inits_wip = false,

.inits_resolved = ini.inits_resolved,

.fully_resolved = false,

},

}),

if (ini.namespace.unwrap()) |namespace| {

ip.extra.appendAssumeCapacity(@intFromEnum(namespace));

}

ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Key.StructType.RuntimeOrder.unresolved), ini.fields_len);

return @enumFromInt(ip.items.len - 1);

.src_scope = fn_owner_decl.src_scope,

/// Provides API for completing an enum type after calling `getIncompleteEnum`.

pub const IncompleteEnumType = struct {

pub fn setTagType(self: @This(), ip: *InternPool, tag_ty: Index) void {

assert(tag_ty == .noreturn_type or ip.isIntegerType(tag_ty));

ip.extra.items[self.tag_ty_index] = @intFromEnum(tag_ty);

/// Returns the already-existing field with the same name, if any.

pub fn addFieldName(

self: @This(),

ip: *InternPool,

name: NullTerminatedString,

) ?u32 {

return ip.addFieldName(self.names_map, self.names_start, name);

/// Returns the already-existing field with the same value, if any.

/// Make sure the type of the value has the integer tag type of the enum.

pub fn addFieldValue(

self: @This(),

ip: *InternPool,

value: Index,

) ?u32 {

assert(ip.typeOf(value) == @as(Index, @enumFromInt(ip.extra.items[self.tag_ty_index])));

const map = &ip.maps.items[@intFromEnum(self.values_map.unwrap().?)];

const indexes = ip.extra.items[self.values_start..][0..field_index];

if (gop.found_existing) return @intCast(gop.index);

ip.extra.items[self.values_start + field_index] = @intFromEnum(value);

};

/// This is used to create an enum type in the `InternPool`, with the ability

/// to update the tag type, field names, and field values later.

pub fn getIncompleteEnum(

ip: *InternPool,

gpa: Allocator,

enum_type: Key.IncompleteEnumType,

) Allocator.Error!IncompleteEnumType {

switch (enum_type.tag_mode) {

.auto => return getIncompleteEnumAuto(ip, gpa, enum_type),

.explicit => return getIncompleteEnumExplicit(ip, gpa, enum_type, .type_enum_explicit),

.nonexhaustive => return getIncompleteEnumExplicit(ip, gpa, enum_type, .type_enum_nonexhaustive),

}

fn getIncompleteEnumAuto(

ip: *InternPool,

gpa: Allocator,

enum_type: Key.IncompleteEnumType,

) Allocator.Error!IncompleteEnumType {

const int_tag_type = if (enum_type.tag_ty != .none)

enum_type.tag_ty

else

try ip.get(gpa, .{ .int_type = .{

.bits = if (enum_type.fields_len == 0) 0 else std.math.log2_int_ceil(u32, enum_type.fields_len),

.signedness = .unsigned,

} });

 

// We must keep the map in sync with `items`. The hash and equality functions

// for enum types only look at the decl field, which is present even in

// an `IncompleteEnumType`.

const adapter: KeyAdapter = .{ .intern_pool = ip };

const gop = try ip.map.getOrPutAdapted(gpa, enum_type.toKey(), adapter);

assert(!gop.found_existing);

 

const names_map = try ip.addMap(gpa, enum_type.fields_len);

 

const extra_fields_len: u32 = @typeInfo(EnumAuto).Struct.fields.len;

try ip.extra.ensureUnusedCapacity(gpa, extra_fields_len + enum_type.fields_len);

try ip.items.ensureUnusedCapacity(gpa, 1);

 

const extra_index = ip.addExtraAssumeCapacity(EnumAuto{

.decl = enum_type.decl,

.namespace = enum_type.namespace,

.int_tag_type = int_tag_type,

.names_map = names_map,

.fields_len = enum_type.fields_len,

.zir_index = enum_type.zir_index,

});

 

ip.items.appendAssumeCapacity(.{

.tag = .type_enum_auto,

.data = extra_index,

});

ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), enum_type.fields_len);

return .{

.index = @enumFromInt(ip.items.len - 1),

.tag_ty_index = extra_index + std.meta.fieldIndex(EnumAuto, "int_tag_type").?,

.names_map = names_map,

.names_start = extra_index + extra_fields_len,

.values_map = .none,

.values_start = undefined,

}

 

fn getIncompleteEnumExplicit(

ip: *InternPool,

gpa: Allocator,

enum_type: Key.IncompleteEnumType,

tag: Tag,

) Allocator.Error!IncompleteEnumType {

// We must keep the map in sync with `items`. The hash and equality functions

// for enum types only look at the decl field, which is present even in

// an `IncompleteEnumType`.

const adapter: KeyAdapter = .{ .intern_pool = ip };

const gop = try ip.map.getOrPutAdapted(gpa, enum_type.toKey(), adapter);

assert(!gop.found_existing);

 

const names_map = try ip.addMap(gpa, enum_type.fields_len);

const values_map: OptionalMapIndex = if (!enum_type.has_values) .none else m: {

const values_map = try ip.addMap(gpa, enum_type.fields_len);

break :m values_map.toOptional();

};

 

const reserved_len = enum_type.fields_len +

if (enum_type.has_values) enum_type.fields_len else 0;

 

const extra_fields_len: u32 = @typeInfo(EnumExplicit).Struct.fields.len;

try ip.extra.ensureUnusedCapacity(gpa, extra_fields_len + reserved_len);

try ip.items.ensureUnusedCapacity(gpa, 1);

 

const extra_index = ip.addExtraAssumeCapacity(EnumExplicit{

.decl = enum_type.decl,

.namespace = enum_type.namespace,

.int_tag_type = enum_type.tag_ty,

.fields_len = enum_type.fields_len,

.names_map = names_map,

.values_map = values_map,

.zir_index = enum_type.zir_index,

});

 

ip.items.appendAssumeCapacity(.{

.tag = tag,

.data = extra_index,

});

// This is both fields and values (if present).

ip.extra.appendNTimesAssumeCapacity(@intFromEnum(Index.none), reserved_len);

return .{

.index = @enumFromInt(ip.items.len - 1),

.tag_ty_index = extra_index + std.meta.fieldIndex(EnumExplicit, "int_tag_type").?,

.names_map = names_map,

.names_start = extra_index + extra_fields_len,

.values_map = values_map,

.values_start = extra_index + extra_fields_len + enum_type.fields_len,

};

}

 

pub const GetEnumInit = struct {

decl: DeclIndex,

namespace: OptionalNamespaceIndex,

tag_ty: Index,

names: []const NullTerminatedString,

values: []const Index,

tag_mode: Key.EnumType.TagMode,

zir_index: TrackedInst.Index.Optional,

pub fn getEnum(ip: *InternPool, gpa: Allocator, ini: GetEnumInit) Allocator.Error!Index {

const gop = try ip.map.getOrPutAdapted(gpa, Key{

.enum_type = .{

// Only the decl is used for hashing and equality.

.decl = ini.decl,

 

.namespace = undefined,

.tag_ty = undefined,

.names = undefined,

.values = undefined,

.tag_mode = undefined,

.names_map = undefined,

.values_map = undefined,

.zir_index = undefined,

},

}, adapter);

if (gop.found_existing) return @enumFromInt(gop.index);

assert(ini.tag_ty == .noreturn_type or ip.isIntegerType(ini.tag_ty));

for (ini.values) |value| assert(ip.typeOf(value) == ini.tag_ty);

const names_map = try ip.addMap(gpa, ini.names.len);

addStringsToMap(ip, names_map, ini.names);

 

const fields_len: u32 = @intCast(ini.names.len);

fields_len);

.namespace = ini.namespace,

.names_map = names_map,

.zir_index = ini.zir_index,

return @enumFromInt(ip.items.len - 1);

.explicit => return finishGetEnum(ip, gpa, ini, .type_enum_explicit),

.nonexhaustive => return finishGetEnum(ip, gpa, ini, .type_enum_nonexhaustive),

pub fn finishGetEnum(

ip: *InternPool,

gpa: Allocator,

ini: GetEnumInit,

tag: Tag,

) Allocator.Error!Index {

const names_map = try ip.addMap(gpa, ini.names.len);

addStringsToMap(ip, names_map, ini.names);

const values_map: OptionalMapIndex = if (ini.values.len == 0) .none else m: {

const values_map = try ip.addMap(gpa, ini.values.len);

addIndexesToMap(ip, values_map, ini.values);

break :m values_map.toOptional();

};

const fields_len: u32 = @intCast(ini.names.len);

try ip.extra.ensureUnusedCapacity(gpa, @typeInfo(EnumExplicit).Struct.fields.len +

fields_len);

ip.items.appendAssumeCapacity(.{

.tag = tag,

.data = ip.addExtraAssumeCapacity(EnumExplicit{

.decl = ini.decl,

.namespace = ini.namespace,

.int_tag_type = ini.tag_ty,

.fields_len = fields_len,

.names_map = names_map,

.values_map = values_map,

.zir_index = ini.zir_index,

}),

ip.extra.appendSliceAssumeCapacity(@ptrCast(ini.names));

ip.extra.appendSliceAssumeCapacity(@ptrCast(ini.values));

return @enumFromInt(ip.items.len - 1);

/// TODO: this is a bit problematic to implement, can we get away without it?

pub const remove = @compileError("InternPool.remove is not currently a supported operation; put a TODO there instead");

.enum_type => |enum_type| return ip.get(gpa, .{ .enum_tag = .{

.int = try ip.getCoerced(gpa, val, enum_type.tag_ty),

.enum_type => |enum_type| {

.struct_type => |struct_type| struct_type.field_types.get(ip)[i],

.type_enum_explicit, .type_enum_nonexhaustive => @sizeOf(EnumExplicit),

.type_enum_auto => @sizeOf(EnumAuto),

.type_opaque => @sizeOf(Key.OpaqueType),

const info = ip.extraData(Tag.TypeStruct, data);

.type_struct_ns => @sizeOf(Module.Namespace),

const info = ip.extraData(Tag.TypeStructPacked, data);

info.fields_len + info.fields_len);

const info = ip.extraData(Tag.TypeStructPacked, data);

info.fields_len + info.fields_len + info.fields_len);

const info = ip.extraData(Tag.TypeUnion, data);

const enum_info = ip.indexToKey(info.tag_ty).enum_type;

const fields_len: u32 = @intCast(enum_info.names.len);

const per_field = @sizeOf(u32); // field type

// 1 byte per field for alignment, rounded up to the nearest 4 bytes

const alignments = if (info.flags.any_aligned_fields)

((fields_len + 3) / 4) * 4

break :b @sizeOf(Tag.TypeUnion) + (fields_len * per_field) + alignments;

.type_struct_ns,

.type_struct_ns,

.struct_type => |struct_type| struct_type.field_types.len,

.struct_type => |struct_type| struct_type.field_types.len,

.type_struct_ns,

pub fn analyze(gpa: Allocator, air: Air, intern_pool: *const InternPool) Allocator.Error!Liveness {

intern_pool: *const InternPool,

/// The index type for this array is `CaptureScope.Index` and the elements here are

/// the indexes of the parent capture scopes.

/// Memory is owned by gpa; garbage collected.

capture_scope_parents: std.ArrayListUnmanaged(CaptureScope.Index) = .{},

/// Value is index of type

/// Memory is owned by gpa; garbage collected.

runtime_capture_scopes: std.AutoArrayHashMapUnmanaged(CaptureScope.Key, InternPool.Index) = .{},

/// Value is index of value

/// Memory is owned by gpa; garbage collected.

comptime_capture_scopes: std.AutoArrayHashMapUnmanaged(CaptureScope.Key, InternPool.Index) = .{},

 

pub const CaptureScope = struct {

pub const Key = extern struct {

zir_index: Zir.Inst.Index,

index: Index,

};

 

/// Index into `capture_scope_parents` which uniquely identifies a capture scope.

pub const Index = enum(u32) {

none = std.math.maxInt(u32),

_,

 

pub fn parent(i: Index, mod: *Module) Index {

return mod.capture_scope_parents.items[@intFromEnum(i)];

}

};

};

 

pub fn createCaptureScope(mod: *Module, parent: CaptureScope.Index) error{OutOfMemory}!CaptureScope.Index {

try mod.capture_scope_parents.append(mod.gpa, parent);

return @enumFromInt(mod.capture_scope_parents.items.len - 1);

}

 

/// The scope which lexically contains this decl.

src_scope: CaptureScope.Index,

 

pub fn getOwnedUnion(decl: Decl, zcu: *Zcu) ?InternPool.UnionType {

else => switch (zcu.intern_pool.indexToKey(decl.val.toIntern())) {

.opaque_type => |opaque_type| opaque_type.namespace.toOptional(),

.struct_type => |struct_type| struct_type.namespace,

.union_type => |union_type| union_type.namespace.toOptional(),

.enum_type => |enum_type| enum_type.namespace,

 

 

zcu.capture_scope_parents.deinit(gpa);

zcu.runtime_capture_scopes.deinit(gpa);

zcu.comptime_capture_scopes.deinit(gpa);

const new_namespace = mod.namespacePtr(new_namespace_index);

const new_decl_index = try mod.allocateNewDecl(new_namespace_index, 0, .none);

new_namespace.decl_index = new_decl_index;

var sema_arena = std.heap.ArenaAllocator.init(gpa);

defer sema_arena.deinit();

const sema_arena_allocator = sema_arena.allocator();

var comptime_mutable_decls = std.ArrayList(Decl.Index).init(gpa);

defer comptime_mutable_decls.deinit();

 

var comptime_err_ret_trace = std.ArrayList(SrcLoc).init(gpa);

defer comptime_err_ret_trace.deinit();

 

var sema: Sema = .{

.mod = mod,

.gpa = gpa,

.arena = sema_arena_allocator,

.code = file.zir,

.owner_decl = new_decl,

.owner_decl_index = new_decl_index,

.func_index = .none,

.func_is_naked = false,

.fn_ret_ty = Type.void,

.fn_ret_ty_ies = null,

.owner_func_index = .none,

.comptime_mutable_decls = &comptime_mutable_decls,

.comptime_err_ret_trace = &comptime_err_ret_trace,

};

defer sema.deinit();

 

const struct_ty = sema.getStructType(

new_decl_index,

new_namespace_index,

try mod.intern_pool.trackZir(gpa, file, .main_struct_inst),

) catch |err| switch (err) {

error.OutOfMemory => return error.OutOfMemory,

};

// TODO: figure out InternPool removals for incremental compilation

//errdefer ip.remove(struct_ty);

for (comptime_mutable_decls.items) |decl_index| {

const decl = mod.declPtr(decl_index);

_ = try decl.internValue(mod);

}

 

new_decl.val = Value.fromInterned(struct_ty);

new_decl.has_tv = true;

new_decl.owns_tv = true;

new_decl.analysis = .complete;

 

const comp = mod.comp;

switch (comp.cache_use) {

.wip_capture_scope = try mod.createCaptureScope(decl.src_scope),

const new_decl_index = try zcu.allocateNewDecl(namespace_index, decl_node, iter.parent_decl.src_scope);

.wip_capture_scope = try mod.createCaptureScope(decl.src_scope),

src_scope: CaptureScope.Index,

.src_scope = src_scope,

return mod.createAnonymousDeclFromDecl(src_decl, block.namespace, block.wip_capture_scope, typed_value);

src_scope: CaptureScope.Index,

const new_decl_index = try mod.allocateNewDecl(namespace, src_decl.src_node, src_scope);

const test_name_decl_index = try mod.createAnonymousDeclFromDecl(decl, decl.src_namespace, .none, .{

const array_decl_index = try mod.createAnonymousDeclFromDecl(decl, decl.src_namespace, .none, .{

const enum_type = ip.indexToKey(ty.toIntern()).enum_type;

pub fn opaqueSrcLoc(mod: *Module, opaque_type: InternPool.Key.OpaqueType) SrcLoc {

return mod.declPtr(opaque_type.decl).srcLoc(mod);

}

 

pub fn opaqueFullyQualifiedName(mod: *Module, opaque_type: InternPool.Key.OpaqueType) !InternPool.NullTerminatedString {

return mod.declPtr(opaque_type.decl).fullyQualifiedName(mod);

}

 

pub fn typeToStruct(mod: *Module, ty: Type) ?InternPool.Key.StructType {

if (ty.ip_index == .none) return null;

return switch (mod.intern_pool.indexToKey(ty.ip_index)) {

.struct_type => |t| t,

else => null,

};

}

 

pub fn typeToPackedStruct(mod: *Module, ty: Type) ?InternPool.Key.StructType {

if (ty.ip_index == .none) return null;

return switch (mod.intern_pool.indexToKey(ty.ip_index)) {

.struct_type => |t| if (t.layout == .Packed) t else null,

else => null,

};

}

 

/// This asserts that the union's enum tag type has been resolved.

pub fn typeToUnion(mod: *Module, ty: Type) ?InternPool.UnionType {

.union_type => |k| ip.loadUnionType(k),

pub fn getUnionLayout(mod: *Module, u: InternPool.UnionType) UnionLayout {

.abi_size = u.size,

.padding = u.padding,

pub fn unionAbiSize(mod: *Module, u: InternPool.UnionType) u64 {

pub fn unionAbiAlignment(mod: *Module, u: InternPool.UnionType) Alignment {

pub fn unionFieldNormalAlignment(mod: *Module, u: InternPool.UnionType, field_index: u32) Alignment {

pub fn unionTagFieldIndex(mod: *Module, u: InternPool.UnionType, enum_tag: Value) ?u32 {

const enum_type = ip.indexToKey(u.enum_tag_ty).enum_type;

return enum_type.tagValueIndex(ip, enum_tag.toIntern());

struct_type: InternPool.Key.StructType,

const digest = Cache.HashHelper.oneShot(generated_builtin_source);

const builtin_sub_path = try arena.dupe(u8, "b" ++ std.fs.path.sep_str ++ digest);

const new = try arena.create(Module);

const CaptureScope = Module.CaptureScope;

wip_capture_scope: CaptureScope.Index,

 

.wip_capture_scope = parent.wip_capture_scope,

// Most of the time, we don't need to construct a new capture scope for a

// block. However, successive iterations of comptime loops can capture

// different values for the same Zir.Inst.Index, so in those cases, we will

// have to create nested capture scopes; see the `.repeat` case below.

const parent_capture_scope = block.wip_capture_scope;

 

.closure_get => try sema.zirClosureGet(block, inst),

.closure_capture => {

try sema.zirClosureCapture(block, inst);

i += 1;

continue;

},

 

// We need to construct new capture scopes for the next loop iteration so it

// can capture values without clobbering the earlier iteration's captures.

block.wip_capture_scope = try mod.createCaptureScope(parent_capture_scope);

 

 

// We need to construct new capture scopes for the next loop iteration so it

// can capture values without clobbering the earlier iteration's captures.

block.wip_capture_scope = try mod.createCaptureScope(parent_capture_scope);

 

 

// We may have overwritten the capture scope due to a `repeat` instruction where

// the body had a capture; restore it now.

block.wip_capture_scope = parent_capture_scope;

pub fn getStructType(

decl: InternPool.DeclIndex,

namespace: InternPool.NamespaceIndex,

tracked_inst: InternPool.TrackedInst.Index,

) !InternPool.Index {

const zir_index = tracked_inst.resolve(ip);

const extended = sema.code.instructions.items(.data)[@intFromEnum(zir_index)].extended;

assert(extended.opcode == .struct_decl);

var extra_index: usize = extended.operand + @typeInfo(Zir.Inst.StructDecl).Struct.fields.len;

const decls = sema.code.bodySlice(extra_index, decls_len);

try mod.scanNamespace(namespace, decls, mod.declPtr(decl));

extra_index += decls_len;

 

const ty = try ip.getStructType(gpa, .{

.decl = decl,

.namespace = namespace.toOptional(),

.zir_index = tracked_inst.toOptional(),

.known_non_opv = small.known_non_opv,

.is_tuple = small.is_tuple,

.any_default_inits = small.any_default_inits,

});

 

return ty;

}

 

fn zirStructDecl(

sema: *Sema,

block: *Block,

extended: Zir.Inst.Extended.InstData,

inst: Zir.Inst.Index,

) CompileError!Air.Inst.Ref {

const mod = sema.mod;

const ip = &mod.intern_pool;

const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);

const src = sema.code.extraData(Zir.Inst.StructDecl, extended.operand).data.src();

 

// Because these three things each reference each other, `undefined`

// placeholders are used before being set after the struct type gains an

// InternPool index.

.ty = Type.noreturn,

.val = Value.@"unreachable",

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

const new_namespace_index = try mod.createNamespace(.{

});

errdefer mod.destroyNamespace(new_namespace_index);

const struct_ty = ty: {

const tracked_inst = try ip.trackZir(mod.gpa, block.getFileScope(mod), inst);

const ty = try sema.getStructType(new_decl_index, new_namespace_index, tracked_inst);

if (sema.builtin_type_target_index != .none) {

ip.resolveBuiltinType(sema.builtin_type_target_index, ty);

break :ty sema.builtin_type_target_index;

}

break :ty ty;

};

// TODO: figure out InternPool removals for incremental compilation

//errdefer ip.remove(struct_ty);

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(struct_ty);

 

const decl_val = sema.analyzeDeclVal(block, src, new_decl_index);

return decl_val;

const src_scope = block.wip_capture_scope;

const new_decl_index = try mod.allocateNewDecl(namespace, src_node, src_scope);

// Because these three things each reference each other, `undefined`

// placeholders are used before being set after the enum type gains an

// InternPool index.

 

var done = false;

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.noreturn,

.val = Value.@"unreachable",

}, small.name_strategy, "enum", inst);

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

errdefer if (!done) mod.abortAnonDecl(new_decl_index);

 

if (sema.mod.comp.debug_incremental) {

try mod.intern_pool.addDependency(

sema.gpa,

InternPool.Depender.wrap(.{ .decl = new_decl_index }),

.{ .src_hash = try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst) },

);

}

 

const new_namespace_index = try mod.createNamespace(.{

.parent = block.namespace.toOptional(),

.decl_index = new_decl_index,

.file_scope = block.getFileScope(mod),

});

errdefer if (!done) mod.destroyNamespace(new_namespace_index);

try mod.scanNamespace(new_namespace_index, decls, new_decl);

const incomplete_enum = incomplete_enum: {

var incomplete_enum = try mod.intern_pool.getIncompleteEnum(gpa, .{

.decl = new_decl_index,

.namespace = new_namespace_index.toOptional(),

.fields_len = fields_len,

.has_values = any_values,

.tag_mode = if (small.nonexhaustive)

.nonexhaustive

else if (tag_type_ref == .none)

.auto

else

.explicit,

.zir_index = (try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst)).toOptional(),

});

if (sema.builtin_type_target_index != .none) {

mod.intern_pool.resolveBuiltinType(sema.builtin_type_target_index, incomplete_enum.index);

incomplete_enum.index = sema.builtin_type_target_index;

}

break :incomplete_enum incomplete_enum;

// TODO: figure out InternPool removals for incremental compilation

//errdefer if (!done) mod.intern_pool.remove(incomplete_enum.index);

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(incomplete_enum.index);

const decl_val = try sema.analyzeDeclVal(block, src, new_decl_index);

try mod.finalizeAnonDecl(new_decl_index);

.namespace = new_namespace_index,

.wip_capture_scope = try mod.createCaptureScope(new_decl.src_scope),

incomplete_enum.setTagType(&mod.intern_pool, ty.toIntern());

assert(incomplete_enum.addFieldName(&mod.intern_pool, field_name) == null);

if (incomplete_enum.addFieldValue(&mod.intern_pool, last_tag_val.?.toIntern())) |other_index| {

const other_field_src = mod.fieldSrcLoc(new_decl_index, .{ .index = other_index }).lazy;

if (incomplete_enum.addFieldValue(&mod.intern_pool, last_tag_val.?.toIntern())) |other_index| {

const other_field_src = mod.fieldSrcLoc(new_decl_index, .{ .index = other_index }).lazy;

return decl_val;

// Because these three things each reference each other, `undefined`

// placeholders are used before being set after the union type gains an

// InternPool index.

.ty = Type.noreturn,

.val = Value.@"unreachable",

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

const new_namespace_index = try mod.createNamespace(.{

});

errdefer mod.destroyNamespace(new_namespace_index);

const union_ty = ty: {

const ty = try mod.intern_pool.getUnionType(gpa, .{

.flags = .{

.layout = small.layout,

.status = .none,

.runtime_tag = if (small.has_tag_type or small.auto_enum_tag)

.tagged

else if (small.layout != .Auto)

.none

else switch (block.wantSafety()) {

true => .safety,

false => .none,

},

.any_aligned_fields = small.any_aligned_fields,

.requires_comptime = .unknown,

.assumed_runtime_bits = false,

.assumed_pointer_aligned = false,

.alignment = .none,

},

.decl = new_decl_index,

.namespace = new_namespace_index,

.zir_index = (try mod.intern_pool.trackZir(gpa, block.getFileScope(mod), inst)).toOptional(),

.fields_len = fields_len,

.enum_tag_ty = .none,

.field_types = &.{},

.field_aligns = &.{},

});

if (sema.builtin_type_target_index != .none) {

mod.intern_pool.resolveBuiltinType(sema.builtin_type_target_index, ty);

break :ty sema.builtin_type_target_index;

}

break :ty ty;

};

// TODO: figure out InternPool removals for incremental compilation

//errdefer mod.intern_pool.remove(union_ty);

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(union_ty);

 

const decls = sema.code.bodySlice(extra_index, decls_len);

try mod.scanNamespace(new_namespace_index, decls, new_decl);

 

const decl_val = sema.analyzeDeclVal(block, src, new_decl_index);

return decl_val;

// Because these three things each reference each other, `undefined`

// placeholders are used in two places before being set after the opaque

// type gains an InternPool index.

.ty = Type.noreturn,

.val = Value.@"unreachable",

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

try mod.intern_pool.addDependency(

sema.gpa,

.{ .src_hash = try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst) },

const new_namespace_index = try mod.createNamespace(.{

});

errdefer mod.destroyNamespace(new_namespace_index);

const opaque_ty = try mod.intern(.{ .opaque_type = .{

.decl = new_decl_index,

.namespace = new_namespace_index,

.zir_index = (try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst)).toOptional(),

} });

// TODO: figure out InternPool removals for incremental compilation

//errdefer mod.intern_pool.remove(opaque_ty);

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(opaque_ty);

 

const decls = sema.code.bodySlice(extra_index, decls_len);

try mod.scanNamespace(new_namespace_index, decls, new_decl);

 

const decl_val = sema.analyzeDeclVal(block, src, new_decl_index);

return decl_val;

struct_type: InternPool.Key.StructType,

union_obj: InternPool.UnionType,

.wip_capture_scope = parent_block.wip_capture_scope,

.wip_capture_scope = parent_block.wip_capture_scope,

.wip_capture_scope = try mod.createCaptureScope(fn_owner_decl.src_scope),

.wip_capture_scope = try mod.createCaptureScope(fn_owner_decl.src_scope),

.wip_capture_scope = block.wip_capture_scope,

.wip_capture_scope = block.wip_capture_scope,

case_block.wip_capture_scope = try mod.createCaptureScope(child_block.wip_capture_scope);

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = try mod.createCaptureScope(child_block.wip_capture_scope);

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = child_block.wip_capture_scope;

case_block.wip_capture_scope = try mod.createCaptureScope(child_block.wip_capture_scope);

const field_index = ip.indexToKey(ip.typeOf(item.val)).enum_type.tagValueIndex(ip, int) orelse {

.struct_type => |struct_type| {

break :hf struct_type.nameIndex(ip, field_name) != null;

.union_type => |union_type| {

const union_obj = ip.loadUnionType(union_type);

break :hf union_obj.nameIndex(ip, field_name) != null;

.enum_type => |enum_type| {

break :hf enum_type.nameIndex(ip, field_name) != null;

fn zirClosureCapture(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void {

const gpa = sema.gpa;

const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok;

// Closures are not necessarily constant values. For example, the

// code might do something like this:

// fn foo(x: anytype) void { const S = struct {field: @TypeOf(x)}; }

// ...in which case the closure_capture instruction has access to a runtime

// value only. In such case only the type is saved into the scope.

const operand = try sema.resolveInst(inst_data.operand);

const ty = sema.typeOf(operand);

const key: CaptureScope.Key = .{

.zir_index = inst,

.index = block.wip_capture_scope,

};

if (try sema.resolveValue(operand)) |val| {

try mod.comptime_capture_scopes.put(gpa, key, try val.intern(ty, mod));

} else {

try mod.runtime_capture_scopes.put(gpa, key, ty.toIntern());

}

}

fn zirClosureGet(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {

const mod = sema.mod;

//const ip = &mod.intern_pool;

const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].inst_node;

var scope: CaptureScope.Index = mod.declPtr(block.src_decl).src_scope;

assert(scope != .none);

// Note: The target closure must be in this scope list.

// If it's not here, the zir is invalid, or the list is broken.

const capture_ty = while (true) {

// Note: We don't need to add a dependency here, because

// decls always depend on their lexical parents.

const key: CaptureScope.Key = .{

.zir_index = inst_data.inst,

.index = scope,

};

if (mod.comptime_capture_scopes.get(key)) |val|

return Air.internedToRef(val);

if (mod.runtime_capture_scopes.get(key)) |ty|

break ty;

scope = scope.parent(mod);

assert(scope != .none);

const node = sema.owner_decl.relativeToNodeIndex(inst_data.src_node);

try sema.errMsg(block, inst_data.src(), "'{s}' not accessible outside function scope", .{some})

try sema.errMsg(block, inst_data.src(), "variable not accessible outside function scope", .{});

const node = sema.owner_decl.relativeToNodeIndex(inst_data.src_node);

try sema.errMsg(block, inst_data.src(), "'{s}' not accessible from inner function", .{some})

try sema.errMsg(block, inst_data.src(), "variable not accessible from inner function", .{});

const is_exhaustive = Value.makeBool(ip.indexToKey(ty.toIntern()).enum_type.tag_mode != .nonexhaustive);

const enum_field_vals = try sema.arena.alloc(InternPool.Index, ip.indexToKey(ty.toIntern()).enum_type.names.len);

const enum_type = ip.indexToKey(ty.toIntern()).enum_type;

const decls_val = try sema.typeInfoDecls(block, src, type_info_ty, ip.indexToKey(ty.toIntern()).enum_type.namespace);

ip.indexToKey(ty.toIntern()).enum_type.tag_ty,

const union_field_vals = try gpa.alloc(InternPool.Index, union_obj.field_names.len);

const name = try sema.arena.dupeZ(u8, ip.stringToSlice(union_obj.field_names.get(ip)[i]));

.struct_type => |s| s,

.wip_capture_scope = block.wip_capture_scope,

.wip_capture_scope = block.wip_capture_scope,

.wip_capture_scope = block.wip_capture_scope,

.struct_type => |struct_type| {

.struct_type => |struct_type| {

const field_index = union_obj.nameIndex(ip, field_name) orelse

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const elem_struct_type = ip.indexToKey(ip.typeOf(elem_val.toIntern())).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

// Decls

const int_tag_ty = tag_type_val.toType();

if (int_tag_ty.zigTypeTag(mod) != .Int) {

return sema.fail(block, src, "Type.Enum.tag_type must be an integer type", .{});

}

 

// Because these things each reference each other, `undefined`

// placeholders are used before being set after the enum type gains

// an InternPool index.

 

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.noreturn,

.val = Value.@"unreachable",

}, name_strategy, "enum", inst);

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

errdefer {

new_decl.has_tv = false; // namespace and val were destroyed by later errdefers

mod.abortAnonDecl(new_decl_index);

}

 

// Define our empty enum decl

const fields_len: u32 = @intCast(try sema.usizeCast(block, src, fields_val.sliceLen(mod)));

const incomplete_enum = try ip.getIncompleteEnum(gpa, .{

.decl = new_decl_index,

.namespace = .none,

.fields_len = fields_len,

.has_values = true,

.tag_mode = if (!is_exhaustive_val.toBool())

.nonexhaustive

else

.explicit,

.tag_ty = int_tag_ty.toIntern(),

.zir_index = .none,

});

// TODO: figure out InternPool removals for incremental compilation

//errdefer ip.remove(incomplete_enum.index);

 

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(incomplete_enum.index);

 

for (0..fields_len) |field_i| {

const elem_val = try fields_val.elemValue(mod, field_i);

const elem_struct_type = ip.indexToKey(ip.typeOf(elem_val.toIntern())).struct_type;

const name_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "name"),

).?);

const value_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "value"),

).?);

 

const field_name = try name_val.toIpString(Type.slice_const_u8, mod);

 

if (!try sema.intFitsInType(value_val, int_tag_ty, null)) {

// TODO: better source location

return sema.fail(block, src, "field '{}' with enumeration value '{}' is too large for backing int type '{}'", .{

field_name.fmt(ip),

value_val.fmtValue(Type.comptime_int, mod),

int_tag_ty.fmt(mod),

});

}

 

if (incomplete_enum.addFieldName(ip, field_name)) |other_index| {

const msg = msg: {

const msg = try sema.errMsg(block, src, "duplicate enum field '{}'", .{

field_name.fmt(ip),

});

errdefer msg.destroy(gpa);

_ = other_index; // TODO: this note is incorrect

try sema.errNote(block, src, msg, "other field here", .{});

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

}

 

if (incomplete_enum.addFieldValue(ip, (try mod.getCoerced(value_val, int_tag_ty)).toIntern())) |other| {

const msg = msg: {

const msg = try sema.errMsg(block, src, "enum tag value {} already taken", .{value_val.fmtValue(Type.comptime_int, mod)});

errdefer msg.destroy(gpa);

_ = other; // TODO: this note is incorrect

try sema.errNote(block, src, msg, "other enum tag value here", .{});

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

}

}

 

const decl_val = sema.analyzeDeclVal(block, src, new_decl_index);

try mod.finalizeAnonDecl(new_decl_index);

return decl_val;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

// Because these three things each reference each other,

// `undefined` placeholders are used in two places before being set

// after the opaque type gains an InternPool index.

.ty = Type.noreturn,

.val = Value.@"unreachable",

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

errdefer {

new_decl.has_tv = false; // namespace and val were destroyed by later errdefers

mod.abortAnonDecl(new_decl_index);

}

const new_namespace_index = try mod.createNamespace(.{

.parent = block.namespace.toOptional(),

.decl_index = new_decl_index,

.file_scope = block.getFileScope(mod),

});

errdefer mod.destroyNamespace(new_namespace_index);

 

const opaque_ty = try mod.intern(.{ .opaque_type = .{

.decl = new_decl_index,

.namespace = new_namespace_index,

.zir_index = .none,

} });

// TODO: figure out InternPool removals for incremental compilation

//errdefer ip.remove(opaque_ty);

 

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(opaque_ty);

 

const decl_val = sema.analyzeDeclVal(block, src, new_decl_index);

return decl_val;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

// Decls

const fields_len: u32 = @intCast(try sema.usizeCast(block, src, fields_val.sliceLen(mod)));

// Tag type

var explicit_tags_seen: []bool = &.{};

var enum_field_names: []InternPool.NullTerminatedString = &.{};

var enum_tag_ty: InternPool.Index = .none;

if (tag_type_val.optionalValue(mod)) |payload_val| {

enum_tag_ty = payload_val.toType().toIntern();

 

const enum_type = switch (ip.indexToKey(enum_tag_ty)) {

.enum_type => |x| x,

else => return sema.fail(block, src, "Type.Union.tag_type must be an enum type", .{}),

};

 

explicit_tags_seen = try sema.arena.alloc(bool, enum_type.names.len);

@memset(explicit_tags_seen, false);

} else {

enum_field_names = try sema.arena.alloc(InternPool.NullTerminatedString, fields_len);

}

 

// Fields

var any_aligned_fields: bool = false;

var union_fields: std.MultiArrayList(struct {

type: InternPool.Index,

alignment: InternPool.Alignment,

}) = .{};

var field_name_table: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void) = .{};

try field_name_table.ensureTotalCapacity(sema.arena, fields_len);

 

for (0..fields_len) |i| {

const elem_val = try fields_val.elemValue(mod, i);

const elem_struct_type = ip.indexToKey(ip.typeOf(elem_val.toIntern())).struct_type;

const name_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "name"),

).?);

const type_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "type"),

).?);

const alignment_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "alignment"),

).?);

 

const field_name = try name_val.toIpString(Type.slice_const_u8, mod);

 

if (enum_field_names.len != 0) {

enum_field_names[i] = field_name;

}

 

if (enum_tag_ty != .none) {

const tag_info = ip.indexToKey(enum_tag_ty).enum_type;

const enum_index = tag_info.nameIndex(ip, field_name) orelse {

return sema.fail(block, src, "no field named '{}' in enum '{}'", .{

field_name.fmt(ip), Type.fromInterned(enum_tag_ty).fmt(mod),

});

};

assert(explicit_tags_seen.len == tag_info.names.len);

// No check for duplicate because the check already happened in order

// to create the enum type in the first place.

assert(!explicit_tags_seen[enum_index]);

explicit_tags_seen[enum_index] = true;

}

 

const gop = field_name_table.getOrPutAssumeCapacity(field_name);

if (gop.found_existing) {

// TODO: better source location

return sema.fail(block, src, "duplicate union field {}", .{field_name.fmt(ip)});

}

 

const field_ty = type_val.toType();

const alignment_val_int = (try alignment_val.getUnsignedIntAdvanced(mod, sema)).?;

if (alignment_val_int > 0 and !math.isPowerOfTwo(alignment_val_int)) {

// TODO: better source location

return sema.fail(block, src, "alignment value '{d}' is not a power of two or zero", .{

alignment_val_int,

});

}

const field_align = Alignment.fromByteUnits(alignment_val_int);

any_aligned_fields = any_aligned_fields or field_align != .none;

 

try union_fields.append(sema.arena, .{

.type = field_ty.toIntern(),

.alignment = field_align,

});

 

if (field_ty.zigTypeTag(mod) == .Opaque) {

const msg = msg: {

const msg = try sema.errMsg(block, src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});

errdefer msg.destroy(gpa);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

}

if (layout == .Extern and !try sema.validateExternType(field_ty, .union_field)) {

const msg = msg: {

const msg = try sema.errMsg(block, src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(mod)});

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

try sema.explainWhyTypeIsNotExtern(msg, src_decl.toSrcLoc(src, mod), field_ty, .union_field);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

} else if (layout == .Packed and !try sema.validatePackedType(field_ty)) {

const msg = msg: {

const msg = try sema.errMsg(block, src, "packed unions cannot contain fields of type '{}'", .{field_ty.fmt(mod)});

errdefer msg.destroy(gpa);

 

const src_decl = mod.declPtr(block.src_decl);

try sema.explainWhyTypeIsNotPacked(msg, src_decl.toSrcLoc(src, mod), field_ty);

 

try sema.addDeclaredHereNote(msg, field_ty);

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

}

}

 

if (enum_tag_ty != .none) {

const tag_info = ip.indexToKey(enum_tag_ty).enum_type;

if (tag_info.names.len > fields_len) {

const msg = msg: {

const msg = try sema.errMsg(block, src, "enum field(s) missing in union", .{});

errdefer msg.destroy(gpa);

 

assert(explicit_tags_seen.len == tag_info.names.len);

for (tag_info.names.get(ip), 0..) |field_name, field_index| {

if (explicit_tags_seen[field_index]) continue;

try sema.addFieldErrNote(Type.fromInterned(enum_tag_ty), field_index, msg, "field '{}' missing, declared here", .{

field_name.fmt(ip),

});

}

try sema.addDeclaredHereNote(msg, Type.fromInterned(enum_tag_ty));

break :msg msg;

};

return sema.failWithOwnedErrorMsg(block, msg);

}

} else {

enum_tag_ty = try sema.generateUnionTagTypeSimple(block, enum_field_names, .none);

}

 

// Because these three things each reference each other, `undefined`

// placeholders are used before being set after the union type gains an

// InternPool index.

 

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.noreturn,

.val = Value.@"unreachable",

}, name_strategy, "union", inst);

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

errdefer {

new_decl.has_tv = false; // namespace and val were destroyed by later errdefers

mod.abortAnonDecl(new_decl_index);

}

 

const new_namespace_index = try mod.createNamespace(.{

.parent = block.namespace.toOptional(),

.decl_index = new_decl_index,

.file_scope = block.getFileScope(mod),

});

errdefer mod.destroyNamespace(new_namespace_index);

 

const union_ty = try ip.getUnionType(gpa, .{

.decl = new_decl_index,

.namespace = new_namespace_index,

.enum_tag_ty = enum_tag_ty,

.fields_len = fields_len,

.zir_index = .none,

.flags = .{

.layout = layout,

.status = .have_field_types,

.runtime_tag = if (!tag_type_val.isNull(mod))

.tagged

else if (layout != .Auto)

.none

else switch (block.wantSafety()) {

true => .safety,

false => .none,

},

.any_aligned_fields = any_aligned_fields,

.requires_comptime = .unknown,

.assumed_runtime_bits = false,

.assumed_pointer_aligned = false,

.alignment = .none,

},

.field_types = union_fields.items(.type),

.field_aligns = if (any_aligned_fields) union_fields.items(.alignment) else &.{},

});

 

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(union_ty);

 

const decl_val = sema.analyzeDeclVal(block, src, new_decl_index);

try mod.finalizeAnonDecl(new_decl_index);

return decl_val;

const struct_type = ip.indexToKey(ip.typeOf(union_val.val)).struct_type;

const elem_struct_type = ip.indexToKey(ip.typeOf(elem_val.toIntern())).struct_type;

backing_int_val: Value,

const fields_len: u32 = @intCast(try sema.usizeCast(block, src, fields_val.sliceLen(mod)));

 

// Because these three things each reference each other, `undefined`

// placeholders are used before being set after the struct type gains an

// InternPool index.

 

.ty = Type.noreturn,

.val = Value.@"unreachable",

const new_decl = mod.declPtr(new_decl_index);

new_decl.owns_tv = true;

errdefer {

new_decl.has_tv = false; // namespace and val were destroyed by later errdefers

mod.abortAnonDecl(new_decl_index);

}

const ty = try ip.getStructType(gpa, .{

.decl = new_decl_index,

.namespace = .none,

.zir_index = .none,

.layout = layout,

.known_non_opv = false,

.fields_len = fields_len,

.requires_comptime = .unknown,

.is_tuple = is_tuple,

// So that we don't have to scan ahead, we allocate space in the struct

// type for alignments, comptime fields, and default inits. This might

// result in wasted space, however, this is a permitted encoding of

// struct types.

.any_comptime_fields = true,

.any_default_inits = true,

.inits_resolved = true,

.any_aligned_fields = true,

});

// TODO: figure out InternPool removals for incremental compilation

//errdefer ip.remove(ty);

const struct_type = ip.indexToKey(ty).struct_type;

new_decl.ty = Type.type;

new_decl.val = Value.fromInterned(ty);

// Fields

for (0..fields_len) |i| {

const elem_val = try fields_val.elemValue(mod, i);

const elem_struct_type = ip.indexToKey(ip.typeOf(elem_val.toIntern())).struct_type;

const name_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "name"),

).?);

const type_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "type"),

).?);

const default_value_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "default_value"),

).?);

const is_comptime_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "is_comptime"),

).?);

const alignment_val = try elem_val.fieldValue(mod, elem_struct_type.nameIndex(

ip,

try ip.getOrPutString(gpa, "alignment"),

).?);

 

if (!try sema.intFitsInType(alignment_val, Type.u32, null)) {

return sema.fail(block, src, "alignment must fit in 'u32'", .{});

}

const abi_align = (try alignment_val.getUnsignedIntAdvanced(mod, sema)).?;

 

if (layout == .Packed) {

if (abi_align != 0) return sema.fail(block, src, "alignment in a packed struct field must be set to 0", .{});

if (is_comptime_val.toBool()) return sema.fail(block, src, "packed struct fields cannot be marked comptime", .{});

} else {

if (abi_align > 0 and !math.isPowerOfTwo(abi_align)) return sema.fail(block, src, "alignment value '{d}' is not a power of two or zero", .{abi_align});

struct_type.field_aligns.get(ip)[i] = Alignment.fromByteUnits(abi_align);

}

if (layout == .Extern and is_comptime_val.toBool()) {

return sema.fail(block, src, "extern struct fields cannot be marked comptime", .{});

}

 

const field_name = try name_val.toIpString(Type.slice_const_u8, mod);

const field_index = field_name.toUnsigned(ip) orelse return sema.fail(

 

if (field_index >= fields_len) {

"tuple field {} exceeds tuple field count",

.{field_index},

const field_ty = type_val.toType();

const default_val = if (default_value_val.optionalValue(mod)) |opt_val|

(try sema.pointerDeref(block, src, opt_val, try mod.singleConstPtrType(field_ty)) orelse

return sema.failWithNeededComptime(block, src, .{

.needed_comptime_reason = "struct field default value must be comptime-known",

})).toIntern()

else

.none;

if (is_comptime_val.toBool() and default_val == .none) {

struct_type.field_types.get(ip)[i] = field_ty.toIntern();

struct_type.field_inits.get(ip)[i] = default_val;

if (is_comptime_val.toBool())

struct_type.setFieldComptime(ip, i);

const msg = msg: {