srctree

const node_tags = tree.nodes.items(.tag);

const main_tokens = tree.nodes.items(.main_token);

const token_tags = tree.tokens.items(.tag);

var decl_count: u32 = 0;

for (members) |member_node| {

const name_token = switch (node_tags[member_node]) {

break :blk ident;

},

 

decl_count += 1;

continue;

},

 

else => continue,

};

 

 

/// Dependencies on the value of a Decl.

/// Value is index into `dep_entries` of the first dependency on this Decl value.

decl_val_deps: std.AutoArrayHashMapUnmanaged(DeclIndex, DepEntry.Index) = .{},

/// Dependencies on the full set of names in a ZIR namespace.

/// Key refers to a `struct_decl`, `union_decl`, etc.

/// Value is index into `dep_entries` of the first dependency on this namespace.

pub const Dependee = union(enum) {

src_hash: TrackedInst.Index,

decl_val: DeclIndex,

namespace: TrackedInst.Index,

namespace_name: NamespaceNameKey,

};

const first_entry = switch (dependee) {

.src_hash => |x| ip.src_hash_deps.get(x),

.decl_val => |x| ip.decl_val_deps.get(x),

.namespace => |x| ip.namespace_deps.get(x),

.namespace_name => |x| ip.namespace_name_deps.get(x),

} orelse return .{

const gop = try switch (tag) {

.src_hash => ip.src_hash_deps,

.decl_val => ip.decl_val_deps,

.namespace => ip.namespace_deps,

.namespace_name => ip.namespace_name_deps,

}.getOrPut(gpa, dependee_payload);

 

ip.src_hash_deps.deinit(gpa);

ip.decl_val_deps.deinit(gpa);

ip.namespace_deps.deinit(gpa);

ip.namespace_name_deps.deinit(gpa);

 

return @enumFromInt(gop.index);

}

 

has_namespace: bool,

key: union(enum) {

declared: struct {

},

};

 

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

const gop = try ip.map.getOrPutAdapted(gpa, Key{ .opaque_type = switch (ini.key) {

.declared => |d| .{ .declared = .{

return ip.extra.items[start + std.meta.fieldIndex(Tag.TypeFunction, "params_len").?];

}

 

const tags = ip.items.items(.tag);

return switch (tags[@intFromEnum(i)]) {

.func_coerced => {

 

src_line: u32,

/// Index of the ZIR `declaration` instruction from which this `Decl` was created.

/// For the root `Decl` of a `File` and legacy anonymous decls, this is `.none`.

 

/// Represents the "shallow" analysis status. For example, for decls that are functions,

/// the function type is analyzed with this set to `in_progress`, however, the semantic

const Index = InternPool.DeclIndex;

const OptionalIndex = InternPool.OptionalDeclIndex;

 

pub fn zirBodies(decl: Decl, zcu: *Zcu) Zir.Inst.Declaration.Bodies {

const zir = decl.getFileScope(zcu).zir;

const pl_node = zir.instructions.items(.data)[@intFromEnum(zir_index)].pl_node;

const extra = zir.extraData(Zir.Inst.Declaration, pl_node.payload_index);

return extra.data.getBodies(@intCast(extra.end), zir);

zcu: *Zcu,

 

pub fn hash(ctx: @This(), decl_index: Decl.Index) u32 {

return std.hash.uint32(@intFromEnum(decl.name));

}

 

pub fn eql(ctx: @This(), a_decl_index: Decl.Index, b_decl_index: Decl.Index, b_index: usize) bool {

_ = b_index;

return a_decl.name == b_decl.name;

}

};

if (opt_po_entry) |e| e.value else 0,

);

log.debug("outdated: {}", .{depender});

// This is a new entry with no PO dependencies.

try zcu.outdated_ready.put(zcu.gpa, depender, {});

}

// If this is a Decl and was not previously PO, we must recursively

// mark dependencies on its tyval as PO.

}

}

 

// as no longer PO.

switch (depender.unwrap()) {

.decl => |decl_index| try zcu.markPoDependeeUpToDate(.{ .decl_val = decl_index }),

}

}

}

 

while (it.next()) |po| {

if (zcu.outdated.getPtr(po)) |po_dep_count| {

// This dependency is already outdated, but it now has one more PO

continue;

}

try zcu.potentially_outdated.putNoClobber(zcu.gpa, po, 1);

}

}

 

pub fn findOutdatedToAnalyze(zcu: *Zcu) Allocator.Error!?InternPool.Depender {

// This Depender was not marked PO, but is now outdated. Mark it as

// such, then recursively mark transitive dependencies as PO.

try zcu.outdated.put(gpa, depender, 0);

}

zcu.retryable_failures.clearRetainingCapacity();

}

}

}

 

/// This ensures that the Decl will have an up-to-date Type and Value populated.

/// However the resolution status of the Type may not be fully resolved.

/// For example an inferred error set is not resolved until after `analyzeFnBody`.

 

const decl = mod.declPtr(decl_index);

 

// Determine whether or not this Decl is outdated, i.e. requires re-analysis

// even if `complete`. If a Decl is PO, we pessismistically assume that it

// *does* require re-analysis, to ensure that the Decl is definitely

// dependencies are all up-to-date.

 

const decl_as_depender = InternPool.Depender.wrap(.{ .decl = decl_index });

mod.potentially_outdated.swapRemove(decl_as_depender);

 

_ = mod.outdated_ready.swapRemove(decl_as_depender);

}

 

switch (decl.analysis) {

.in_progress => unreachable,

 

};

}

 

break :blk mod.semaDecl(decl_index) catch |err| switch (err) {

error.AnalysisFail => {

if (decl.analysis == .in_progress) {

};

 

// TODO: we do not yet have separate dependencies for decl values vs types.

if (sema_result.invalidate_decl_val or sema_result.invalidate_decl_ref) {

// This dependency was marked as PO, meaning dependees were waiting

// on its analysis result, and it has turned out to be outdated.

// Update dependees accordingly.

try mod.markDependeeOutdated(.{ .decl_val = decl_index });

} else {

// This dependency was previously PO, but turned out to be up-to-date.

// We do not need to queue successive analysis.

try mod.markPoDependeeUpToDate(.{ .decl_val = decl_index });

}

}

 

const tracy = trace(@src());

defer tracy.end();

 

const ip = &zcu.intern_pool;

const decl_index = func.owner_decl;

const decl = zcu.declPtr(decl_index);

 

switch (decl.analysis) {

.unreferenced => unreachable,

.in_progress => unreachable,

}

 

switch (func.analysis(ip).state) {

.sema_failure,

.dependency_failure,

.codegen_failure,

.inline_only => unreachable, // don't queue work for this

}

 

 

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

defer tmp_arena.deinit();

};

defer air.deinit(gpa);

 

const comp = zcu.comp;

 

const dump_air = build_options.enable_debug_extensions and comp.verbose_air;

/// https://github.com/ziglang/zig/issues/14307

pub fn semaPkg(mod: *Module, pkg: *Package.Module) !void {

const file = (try mod.importPkg(pkg)).file;

}

 

fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespace.Index, file: *File) Allocator.Error!InternPool.Index {

return wip_ty.finish(ip, decl_index, namespace_index.toOptional());

}

 

const tracy = trace(@src());

defer tracy.end();

 

 

const gpa = mod.gpa;

log.debug("semaFile mod={s} sub_file_path={s}", .{

},

.incremental => {},

}

}

 

const SemaDeclResult = packed struct {

return error.AnalysisFail;

}

 

}

 

 

const gpa = mod.gpa;

const zir = decl.getFileScope(mod).zir;

return result;

}

 

pub const ImportFileResult = struct {

file: *File,

is_new: bool,

const gpa = zcu.gpa;

const namespace = zcu.namespacePtr(namespace_index);

 

try zcu.comp.work_queue.ensureUnusedCapacity(decls.len);

try namespace.decls.ensureTotalCapacity(gpa, decls.len);

 

var scan_decl_iter: ScanDeclIter = .{

.zcu = zcu,

.namespace_index = namespace_index,

.parent_decl = parent_decl,

};

for (decls) |decl_inst| {

try scanDecl(&scan_decl_iter, decl_inst);

}

}

 

const ScanDeclIter = struct {

zcu: *Zcu,

namespace_index: Namespace.Index,

parent_decl: *Decl,

usingnamespace_index: usize = 0,

comptime_index: usize = 0,

unnamed_test_index: usize = 0,

};

 

fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void {

// Every Decl needs a name.

const decl_name: InternPool.NullTerminatedString, const kind: Decl.Kind, const is_named_test: bool = switch (declaration.name) {

.@"comptime" => info: {

const i = iter.comptime_index;

iter.comptime_index += 1;

break :info .{

.@"comptime",

false,

};

},

.@"usingnamespace" => info: {

const i = iter.usingnamespace_index;

iter.usingnamespace_index += 1;

break :info .{

.@"usingnamespace",

false,

};

},

.unnamed_test => info: {

const i = iter.unnamed_test_index;

iter.unnamed_test_index += 1;

break :info .{

.@"test",

false,

};

},

.decltest => info: {

assert(declaration.flags.has_doc_comment);

const name = zir.nullTerminatedString(@enumFromInt(zir.extra[extra.end]));

break :info .{

.@"test",

true,

};

},

},

};

 

 

// We create a Decl for it regardless of analysis status.

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

const new_decl = zcu.declPtr(new_decl_index);

new_decl.kind = kind;

new_decl.name = decl_name;

new_decl.src_line = line;

new_decl.is_pub = declaration.flags.is_pub;

new_decl.is_exported = declaration.flags.is_export;

 

if (decl.getOwnedFunction(zcu) != null) {

// TODO Look into detecting when this would be unnecessary by storing enough state

// in `Decl` to notice that the line number did not change.

comp.work_queue.writeItemAssumeCapacity(.{ .update_line_number = decl_index });

};

defer sema.deinit();

 

if (func.analysis(ip).inferred_error_set) {

const ies = try arena.create(Sema.InferredErrorSet);

ies.* = .{ .func = func_index };

 

return captures;

}

 

fn zirStructDecl(

sema: *Sema,

block: *Block,

}

}

 

.layout = small.layout,

.fields_len = fields_len,

.known_non_opv = small.known_non_opv,

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

.captures = captures,

} },

};

errdefer wip_ty.cancel(ip);

 

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

if (bag != 0) break true;

} else false;

 

.has_namespace = true or decls_len > 0, // TODO: see below

.has_values = any_values,

.tag_mode = if (small.nonexhaustive)

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

.captures = captures,

} },

};

 

// Once this is `true`, we will not delete the decl or type even upon failure, since we

// have finished constructing the type and are in the process of analyzing it.

const captures = try sema.getCaptures(block, extra_index, captures_len);

extra_index += captures_len;

 

.flags = .{

.layout = small.layout,

.status = .none,

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

.captures = captures,

} },

};

errdefer wip_ty.cancel(ip);

 

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

const captures = try sema.getCaptures(block, extra_index, captures_len);

extra_index += captures_len;

 

.has_namespace = decls_len != 0,

.key = .{ .declared = .{

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

.captures = captures,

} },

.wip => |wip| wip,

};

errdefer wip_ty.cancel(ip);

 

mod.astGenFile(result.file) catch |err|

return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});

 

const file_root_decl_index = result.file.root_decl.unwrap().?;

return sema.analyzeDeclVal(parent_block, src, file_root_decl_index);

}

return sema.fail(block, operand_src, "unable to open '{s}': {s}", .{ operand, @errorName(err) });

},

};

const file_root_decl_index = result.file.root_decl.unwrap().?;

return sema.analyzeDeclVal(block, operand_src, file_root_decl_index);

}

const ip = &mod.intern_pool;

const func_index = ip.iesFuncIndex(ies_index);

const func = mod.funcInfo(func_index);

const resolved_ty = func.resolvedErrorSet(ip).*;

if (resolved_ty != .none) return resolved_ty;

if (func.analysis(ip).state == .in_progress)

return sema.fail(block, src, "unable to resolve inferred error set", .{});

 

 

pub fn declareDependency(sema: *Sema, dependee: InternPool.Dependee) !void {

if (!sema.mod.comp.debug_incremental) return;

const depender = InternPool.Depender.wrap(

if (sema.owner_func_index != .none)

.{ .func = sema.owner_func_index }

 

 

// target=native

// is_test=true

//